From d7f88600135c0fdbf90523b7ef5b762f57e55c91 Mon Sep 17 00:00:00 2001 From: dirak Date: Wed, 12 Aug 2020 13:12:30 +0300 Subject: [PATCH 01/68] improved memory consuming, fixed some bugs From 637a9db330bd91bb86f5f408b10d4c3e456ab674 Mon Sep 17 00:00:00 2001 From: dirak Date: Wed, 12 Aug 2020 13:13:18 +0300 Subject: [PATCH 02/68] improved memory consuming, fixed some bugs --- .../siegmar/fastcsv/reader/CsvContainer.java | 76 ++++++ .../de/siegmar/fastcsv/reader/CsvParser.java | 144 ++++++++++++ .../de/siegmar/fastcsv/reader/CsvReader.java | 206 ++++++++++++++++ .../de/siegmar/fastcsv/reader/CsvRow.java | 165 +++++++++++++ .../fastcsv/reader/ReusableStringBuilder.java | 90 +++++++ .../de/siegmar/fastcsv/reader/RowReader.java | 219 ++++++++++++++++++ .../siegmar/fastcsv/writer/CsvAppender.java | 146 ++++++++++++ .../de/siegmar/fastcsv/writer/CsvWriter.java | 191 +++++++++++++++ .../fastcsv/writer/FastBufferedWriter.java | 80 +++++++ .../fusionsoft/dbgit/adapters/DBAdapter.java | 2 - .../ru/fusionsoft/dbgit/command/CmdAdd.java | 4 +- .../ru/fusionsoft/dbgit/core/DBGitPath.java | 2 +- .../dbgit/data_table/BooleanData.java | 23 +- .../fusionsoft/dbgit/data_table/DateData.java | 32 ++- .../fusionsoft/dbgit/data_table/LongData.java | 29 ++- .../dbgit/data_table/MapFileData.java | 7 +- .../fusionsoft/dbgit/data_table/RowData.java | 149 ++++++++---- .../ru/fusionsoft/dbgit/meta/IMetaObject.java | 28 ++- .../fusionsoft/dbgit/meta/MetaFunction.java | 9 +- .../fusionsoft/dbgit/meta/MetaProcedure.java | 5 +- .../ru/fusionsoft/dbgit/meta/MetaTable.java | 29 +-- .../fusionsoft/dbgit/meta/MetaTableData.java | 164 ++++++++----- .../dbgit/mysql/DBRestoreTableDataMySql.java | 2 +- .../dbgit/postgres/DBAdapterPostgres.java | 10 +- .../postgres/DBRestoreTableDataPostgres.java | 64 +---- src/main/resources/lang/eng.yaml | 1 + 26 files changed, 1660 insertions(+), 217 deletions(-) create mode 100644 src/main/java/de/siegmar/fastcsv/reader/CsvContainer.java create mode 100644 src/main/java/de/siegmar/fastcsv/reader/CsvParser.java create mode 100644 src/main/java/de/siegmar/fastcsv/reader/CsvReader.java create mode 100644 src/main/java/de/siegmar/fastcsv/reader/CsvRow.java create mode 100644 src/main/java/de/siegmar/fastcsv/reader/ReusableStringBuilder.java create mode 100644 src/main/java/de/siegmar/fastcsv/reader/RowReader.java create mode 100644 src/main/java/de/siegmar/fastcsv/writer/CsvAppender.java create mode 100644 src/main/java/de/siegmar/fastcsv/writer/CsvWriter.java create mode 100644 src/main/java/de/siegmar/fastcsv/writer/FastBufferedWriter.java diff --git a/src/main/java/de/siegmar/fastcsv/reader/CsvContainer.java b/src/main/java/de/siegmar/fastcsv/reader/CsvContainer.java new file mode 100644 index 0000000..e638e0a --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/reader/CsvContainer.java @@ -0,0 +1,76 @@ +/* + * Copyright 2015 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.reader; + +import java.util.Collections; +import java.util.List; + +/** + * Class for holding a complete CSV file. + * + * @author Oliver Siegmar + */ +public final class CsvContainer { + + private final List header; + private final List rows; + + CsvContainer(final List header, final List rows) { + this.header = header; + this.rows = rows; + } + + /** + * Returns the number of rows in this container. + * + * @return the number of rows in this container + */ + public int getRowCount() { + return rows.size(); + } + + /** + * Returns the header row - might be {@code null} if no header exists. + * The returned list is unmodifiable. + * + * @return the header row - might be {@code null} if no header exists + */ + public List getHeader() { + return header; + } + + /** + * Returns a CsvRow by its index (starting with 0). + * + * @param index index of the row to return + * @return the row by its index + * @throws IndexOutOfBoundsException if index is out of range + */ + public CsvRow getRow(final int index) { + return rows.get(index); + } + + /** + * Returns an unmodifiable list of rows. + * + * @return an unmodifiable list of rows + */ + public List getRows() { + return Collections.unmodifiableList(rows); + } + +} diff --git a/src/main/java/de/siegmar/fastcsv/reader/CsvParser.java b/src/main/java/de/siegmar/fastcsv/reader/CsvParser.java new file mode 100644 index 0000000..19bb1b4 --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/reader/CsvParser.java @@ -0,0 +1,144 @@ +/* + * Copyright 2015 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.reader; + +import java.io.Closeable; +import java.io.IOException; +import java.io.Reader; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +/** + * This class is responsible for parsing CSV data from the passed-in Reader. + * + * @author Oliver Siegmar + */ +public final class CsvParser implements Closeable { + + private final RowReader rowReader; + private final boolean containsHeader; + private final boolean skipEmptyRows; + private final boolean errorOnDifferentFieldCount; + + private Map headerMap; + private List headerList; + private long lineNo; + private int firstLineFieldCount = -1; + + CsvParser(final Reader reader, final char fieldSeparator, final char textDelimiter, + final boolean containsHeader, final boolean skipEmptyRows, + final boolean errorOnDifferentFieldCount) { + + rowReader = new RowReader(reader, fieldSeparator, textDelimiter); + this.containsHeader = containsHeader; + this.skipEmptyRows = skipEmptyRows; + this.errorOnDifferentFieldCount = errorOnDifferentFieldCount; + } + + /** + * Returns the header fields - {@code null} if no header exists. The returned list is + * unmodifiable. Use {@link CsvReader#setContainsHeader(boolean)} to enable header parsing. + * Also note, that the header is only available after first invocation of + * {@link #nextRow()}. + * + * @return the header fields + * @throws IllegalStateException if header parsing is not enabled or {@link #nextRow()} wasn't + * called before. + */ + public List getHeader() { + if (!containsHeader) { + throw new IllegalStateException("No header available - header parsing is disabled"); + } + if (lineNo == 0) { + throw new IllegalStateException("No header available - call nextRow() first"); + } + return headerList; + } + + /** + * Reads a complete {@link CsvRow} that might be made up of multiple lines in the underlying + * CSV file. + * + * @return a CsvRow or {@code null} if end of file reached + * @throws IOException if an error occurred while reading data + */ + public CsvRow nextRow() throws IOException { + while (!rowReader.isFinished()) { + final long startingLineNo = lineNo + 1; + final RowReader.Line line = rowReader.readLine(); + final String[] currentFields = line.getFields(); + lineNo += line.getLines(); + + final int fieldCount = currentFields.length; + + // reached end of data in a new line? + if (fieldCount == 0) { + break; + } + + // skip empty rows + if (skipEmptyRows && fieldCount == 1 && currentFields[0].isEmpty()) { + continue; + } + + // check the field count consistency on every row + if (errorOnDifferentFieldCount) { + if (firstLineFieldCount == -1) { + firstLineFieldCount = fieldCount; + } else if (fieldCount != firstLineFieldCount) { + throw new IOException( + String.format("Line %d has %d fields, but first line has %d fields", + lineNo, fieldCount, firstLineFieldCount)); + } + } + + final List fieldList = Arrays.asList(currentFields); + + // initialize header + if (containsHeader && headerList == null) { + initHeader(fieldList); + continue; + } + + return new CsvRow(startingLineNo, headerMap, fieldList); + } + + return null; + } + + private void initHeader(final List currentFields) { + headerList = Collections.unmodifiableList(currentFields); + + final Map localHeaderMap = new LinkedHashMap<>(currentFields.size()); + for (int i = 0; i < currentFields.size(); i++) { + final String field = currentFields.get(i); + if (field != null && !field.isEmpty() && !localHeaderMap.containsKey(field)) { + localHeaderMap.put(field, i); + } + } + headerMap = Collections.unmodifiableMap(localHeaderMap); + } + + @Override + public void close() throws IOException { + rowReader.close(); + } + +} diff --git a/src/main/java/de/siegmar/fastcsv/reader/CsvReader.java b/src/main/java/de/siegmar/fastcsv/reader/CsvReader.java new file mode 100644 index 0000000..9e929b2 --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/reader/CsvReader.java @@ -0,0 +1,206 @@ +/* + * Copyright 2015 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.reader; + +import java.io.File; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.Reader; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardOpenOption; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +/** + * This is the main class for reading CSV data. + * + * @author Oliver Siegmar + */ +public final class CsvReader { + + /** + * Field separator character (default: ',' - comma). + */ + private char fieldSeparator = ','; + + /** + * Text delimiter character (default: '"' - double quotes). + */ + private char textDelimiter = '"'; + + /** + * Read first line as header line? (default: false). + */ + private boolean containsHeader; + + /** + * Skip empty rows? (default: true) + */ + private boolean skipEmptyRows = true; + + /** + * Throw an exception if CSV data contains different field count? (default: false). + */ + private boolean errorOnDifferentFieldCount; + + /** + * Sets the field separator character (default: ',' - comma). + */ + public void setFieldSeparator(final char fieldSeparator) { + this.fieldSeparator = fieldSeparator; + } + + /** + * Sets the text delimiter character (default: '"' - double quotes). + */ + public void setTextDelimiter(final char textDelimiter) { + this.textDelimiter = textDelimiter; + } + + /** + * Specifies if the first line should be the header (default: false). + */ + public void setContainsHeader(final boolean containsHeader) { + this.containsHeader = containsHeader; + } + + /** + * Specifies if empty rows should be skipped (default: true). + */ + public void setSkipEmptyRows(final boolean skipEmptyRows) { + this.skipEmptyRows = skipEmptyRows; + } + + /** + * Specifies if an exception should be thrown, if CSV data contains different field count + * (default: false). + */ + public void setErrorOnDifferentFieldCount(final boolean errorOnDifferentFieldCount) { + this.errorOnDifferentFieldCount = errorOnDifferentFieldCount; + } + + /** + * Reads an entire file and returns a CsvContainer containing the data. + * + * @param file the file to read data from. + * @param charset the character set to use - must not be {@code null}. + * @return the entire file's data - never {@code null}. + * @throws IOException if an I/O error occurs. + */ + public CsvContainer read(final File file, final Charset charset) throws IOException { + return read( + Objects.requireNonNull(file.toPath(), "file must not be null"), + Objects.requireNonNull(charset, "charset must not be null") + ); + } + + /** + * Reads an entire file and returns a CsvContainer containing the data. + * + * @param path the file to read data from. + * @param charset the character set to use - must not be {@code null}. + * @return the entire file's data - never {@code null}. + * @throws IOException if an I/O error occurs. + */ + public CsvContainer read(final Path path, final Charset charset) throws IOException { + Objects.requireNonNull(path, "path must not be null"); + Objects.requireNonNull(charset, "charset must not be null"); + try (final Reader reader = newPathReader(path, charset)) { + return read(reader); + } + } + + /** + * Reads from the provided reader until the end and returns a CsvContainer containing the data. + * + * This library uses built-in buffering, so you do not need to pass in a buffered Reader + * implementation such as {@link java.io.BufferedReader}. + * Performance may be even likely better if you do not. + * + * @param reader the data source to read from. + * @return the entire file's data - never {@code null}. + * @throws IOException if an I/O error occurs. + */ + public CsvContainer read(final Reader reader) throws IOException { + final CsvParser csvParser = + parse(Objects.requireNonNull(reader, "reader must not be null")); + + final List rows = new ArrayList<>(); + CsvRow csvRow; + while ((csvRow = csvParser.nextRow()) != null) { + rows.add(csvRow); + } + + final List header = containsHeader ? csvParser.getHeader() : null; + return new CsvContainer(header, rows); + } + + /** + * Constructs a new {@link CsvParser} for the specified arguments. + * + * @param path the file to read data from. + * @param charset the character set to use - must not be {@code null}. + * @return a new CsvParser - never {@code null}. + * @throws IOException if an I/O error occurs. + */ + public CsvParser parse(final Path path, final Charset charset) throws IOException { + return parse(newPathReader( + Objects.requireNonNull(path, "path must not be null"), + Objects.requireNonNull(charset, "charset must not be null") + )); + } + + /** + * Constructs a new {@link CsvParser} for the specified arguments. + * + * @param file the file to read data from. + * @param charset the character set to use - must not be {@code null}. + * @return a new CsvParser - never {@code null}. + * @throws IOException if an I/O error occurs. + */ + public CsvParser parse(final File file, final Charset charset) throws IOException { + return parse( + Objects.requireNonNull(file, "file must not be null").toPath(), + Objects.requireNonNull(charset, "charset must not be null") + ); + } + + /** + * Constructs a new {@link CsvParser} for the specified arguments. + * + * This library uses built-in buffering, so you do not need to pass in a buffered Reader + * implementation such as {@link java.io.BufferedReader}. + * Performance may be even likely better if you do not. + * + * @param reader the data source to read from. + * @return a new CsvParser - never {@code null}. + * @throws IOException if an I/O error occurs. + */ + public CsvParser parse(final Reader reader) throws IOException { + return new CsvParser(Objects.requireNonNull(reader, "reader must not be null"), + fieldSeparator, textDelimiter, containsHeader, skipEmptyRows, + errorOnDifferentFieldCount); + } + + private static Reader newPathReader(final Path path, final Charset charset) throws IOException { + return new InputStreamReader(Files.newInputStream(path, StandardOpenOption.READ), charset); + } + +} diff --git a/src/main/java/de/siegmar/fastcsv/reader/CsvRow.java b/src/main/java/de/siegmar/fastcsv/reader/CsvRow.java new file mode 100644 index 0000000..cc6e076 --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/reader/CsvRow.java @@ -0,0 +1,165 @@ +/* + * Copyright 2015 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.reader; + +import java.util.Collections; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +/** + * This class represents a single CSV row. + * + * @author Oliver Siegmar + */ +public final class CsvRow { + + /** + * The original line number (empty lines may be skipped). + */ + private final long originalLineNumber; + + private final Map headerMap; + private final List fields; + + CsvRow(final long originalLineNumber, final Map headerMap, + final List fields) { + + this.originalLineNumber = originalLineNumber; + this.headerMap = headerMap; + this.fields = fields; + } + + /** + * Returns the original line number (starting with 1). On multi-line rows this is the starting + * line number. Empty lines could be skipped via {@link CsvReader#setSkipEmptyRows(boolean)}. + * + * @return the original line number + */ + public long getOriginalLineNumber() { + return originalLineNumber; + } + + /** + * Gets a field value by its index (starting with 0). + * + * @param index index of the field to return + * @return field value + * @throws IndexOutOfBoundsException if index is out of range + */ + public String getField(final int index) { + return fields.get(index); + } + + /** + * Gets a field value by its name. + * + * @param name field name + * @return field value, {@code null} if this row has no such field + * @throws IllegalStateException if CSV is read without headers - + * see {@link CsvReader#containsHeader} + */ + public String getField(final String name) { + if (headerMap == null) { + throw new IllegalStateException("No header available"); + } + + final Integer col = headerMap.get(name); + if (col != null && col < fields.size()) { + return fields.get(col); + } + + return null; + } + + /** + * Gets all fields of this row as an unmodifiable List. + * + * @return all fields of this row + */ + public List getFields() { + return Collections.unmodifiableList(fields); + } + + /** + * Gets an unmodifiable map of header names and field values of this row. + * + * The map will always contain all header names - even if their value is {@code null}. + * + * @return an unmodifiable map of header names and field values of this row + * @throws IllegalStateException if CSV is read without headers - see + * {@link CsvReader#containsHeader} + */ + public Map getFieldMap() { + if (headerMap == null) { + throw new IllegalStateException("No header available"); + } + + final Map fieldMap = new LinkedHashMap<>(headerMap.size()); + for (final Map.Entry header : headerMap.entrySet()) { + final String key = header.getKey(); + final Integer col = headerMap.get(key); + final String val = col != null && col < fields.size() ? fields.get(col) : null; + fieldMap.put(key, val); + } + + return Collections.unmodifiableMap(fieldMap); + } + + /** + * Gets the number of fields of this row. + * + * @return the number of fields of this row + */ + public int getFieldCount() { + return fields.size(); + } + + @Override + public String toString() { + final StringBuilder sb = new StringBuilder("CsvRow{"); + sb.append("originalLineNumber="); + sb.append(originalLineNumber); + sb.append(", "); + + sb.append("fields="); + if (headerMap != null) { + sb.append('{'); + for (final Iterator> it = + getFieldMap().entrySet().iterator(); it.hasNext();) { + + final Map.Entry entry = it.next(); + sb.append(entry.getKey()); + sb.append('='); + if (entry.getValue() != null) { + sb.append(entry.getValue()); + } + if (it.hasNext()) { + sb.append(", "); + } + } + sb.append('}'); + } else { + sb.append(fields.toString()); + } + + sb.append('}'); + return sb.toString(); + } + +} diff --git a/src/main/java/de/siegmar/fastcsv/reader/ReusableStringBuilder.java b/src/main/java/de/siegmar/fastcsv/reader/ReusableStringBuilder.java new file mode 100644 index 0000000..1938a6e --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/reader/ReusableStringBuilder.java @@ -0,0 +1,90 @@ +/* + * Copyright 2015 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.reader; + +import java.util.Arrays; + +/** + * Resettable / reusable and thus high performance replacement for StringBuilder. + * + * This class is intended for internal use only. + * + * @author Oliver Siegmar + */ + +final class ReusableStringBuilder { + + private static final String EMPTY = ""; + + private char[] buf; + private int pos; + + /** + * Initializes the buffer with the specified capacity. + * + * @param initialCapacity the initial buffer capacity. + */ + ReusableStringBuilder(final int initialCapacity) { + buf = new char[initialCapacity]; + } + + /** + * Appends a character to the buffer, resizing the buffer if needed. + * + * @param c the character to add to the buffer + */ + public void append(final char c) { + if (pos == buf.length) { + buf = Arrays.copyOf(buf, buf.length * 2); + } + buf[pos++] = c; + } + + public void append(final char[] src, final int srcPos, final int length) { + if (pos + length > buf.length) { + int newSize = buf.length * 2; + while (pos + length > newSize) { + newSize *= 2; + } + buf = Arrays.copyOf(buf, newSize); + } + System.arraycopy(src, srcPos, buf, pos, length); + pos += length; + } + + /** + * @return {@code true} if the buffer contains content + */ + public boolean hasContent() { + return pos > 0; + } + + /** + * Returns the string representation of the buffer and resets the buffer. + * + * @return the string representation of the buffer + */ + public String toStringAndReset() { + if (pos > 0) { + final String s = new String(buf, 0, pos); + pos = 0; + return s; + } + return EMPTY; + } + +} diff --git a/src/main/java/de/siegmar/fastcsv/reader/RowReader.java b/src/main/java/de/siegmar/fastcsv/reader/RowReader.java new file mode 100644 index 0000000..a7a2265 --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/reader/RowReader.java @@ -0,0 +1,219 @@ +/* + * Copyright 2018 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.reader; + +import java.io.Closeable; +import java.io.IOException; +import java.io.Reader; +import java.util.Arrays; + +final class RowReader implements Closeable { + + private static final char LF = '\n'; + private static final char CR = '\r'; + private static final int BUFFER_SIZE = 8192; + + private static final int FIELD_MODE_RESET = 0; + private static final int FIELD_MODE_QUOTED = 1; + private static final int FIELD_MODE_NON_QUOTED = 2; + private static final int FIELD_MODE_QUOTE_ON = 4; + private static final int FIELD_MODE_QUOTED_EMPTY = 8; + + private final Reader reader; + private final char fieldSeparator; + private final char textDelimiter; + private final char[] buf = new char[BUFFER_SIZE]; + private final Line line = new Line(32); + private final ReusableStringBuilder currentField = new ReusableStringBuilder(512); + private int bufPos; + private int bufLen; + private int prevChar = -1; + private int copyStart; + private boolean finished; + + RowReader(final Reader reader, final char fieldSeparator, final char textDelimiter) { + this.reader = reader; + this.fieldSeparator = fieldSeparator; + this.textDelimiter = textDelimiter; + } + + /* + * ugly, performance optimized code begins + */ + Line readLine() throws IOException { + // get fields local for higher performance + final Line localLine = line.reset(); + final ReusableStringBuilder localCurrentField = currentField; + final char[] localBuf = buf; + int localBufPos = bufPos; + int localPrevChar = prevChar; + int localCopyStart = copyStart; + + int copyLen = 0; + int fieldMode = FIELD_MODE_RESET; + int lines = 1; + + while (true) { + if (bufLen == localBufPos) { + // end of buffer + + if (copyLen > 0) { + localCurrentField.append(localBuf, localCopyStart, copyLen); + } + bufLen = reader.read(localBuf, 0, localBuf.length); + + if (bufLen < 0) { + // end of data + finished = true; + + if (localPrevChar == fieldSeparator + || (fieldMode & FIELD_MODE_QUOTED_EMPTY) == FIELD_MODE_QUOTED_EMPTY + || localCurrentField.hasContent() + ) { + localLine.addField(localCurrentField.toStringAndReset()); + } + + break; + } + + localCopyStart = localBufPos = copyLen = 0; + } + + final char c = localBuf[localBufPos++]; + + if ((fieldMode & FIELD_MODE_QUOTE_ON) != 0) { + if (c == textDelimiter) { + // End of quoted text + fieldMode &= ~FIELD_MODE_QUOTE_ON; + if (copyLen > 0) { + localCurrentField.append(localBuf, localCopyStart, copyLen); + copyLen = 0; + } else { + fieldMode |= FIELD_MODE_QUOTED_EMPTY; + } + localCopyStart = localBufPos; + } else { + if (c == CR || c == LF && prevChar != CR) { + lines++; + } + copyLen++; + } + } else { + if (c == fieldSeparator) { + if (copyLen > 0) { + localCurrentField.append(localBuf, localCopyStart, copyLen); + copyLen = 0; + } + localLine.addField(localCurrentField.toStringAndReset()); + localCopyStart = localBufPos; + fieldMode = FIELD_MODE_RESET; + } else if (c == textDelimiter && (fieldMode & FIELD_MODE_NON_QUOTED) == 0) { + // Quoted text starts + fieldMode = FIELD_MODE_QUOTED | FIELD_MODE_QUOTE_ON; + + if (localPrevChar == textDelimiter) { + // escaped quote + copyLen++; + } else { + localCopyStart = localBufPos; + } + } else if (c == CR) { + if (copyLen > 0) { + localCurrentField.append(localBuf, localCopyStart, copyLen); + } + localLine.addField(localCurrentField.toStringAndReset()); + localPrevChar = c; + localCopyStart = localBufPos; + break; + } else if (c == LF) { + if (localPrevChar != CR) { + if (copyLen > 0) { + localCurrentField.append(localBuf, localCopyStart, copyLen); + } + localLine.addField(localCurrentField.toStringAndReset()); + localPrevChar = c; + localCopyStart = localBufPos; + break; + } + localCopyStart = localBufPos; + } else { + copyLen++; + if (fieldMode == FIELD_MODE_RESET) { + fieldMode = FIELD_MODE_NON_QUOTED; + } + } + } + + localPrevChar = c; + } + + // restore fields + bufPos = localBufPos; + prevChar = localPrevChar; + copyStart = localCopyStart; + + localLine.setLines(lines); + return localLine; + } + + @Override + public void close() throws IOException { + reader.close(); + } + + public boolean isFinished() { + return finished; + } + + static final class Line { + + private String[] fields; + private int linePos; + private int lines; + + Line(final int initialCapacity) { + fields = new String[initialCapacity]; + } + + Line reset() { + linePos = 0; + lines = 1; + return this; + } + + void addField(final String field) { + if (linePos == fields.length) { + fields = Arrays.copyOf(fields, fields.length * 2); + } + fields[linePos++] = field; + } + + String[] getFields() { + return Arrays.copyOf(fields, linePos); + } + + int getLines() { + return lines; + } + + void setLines(final int lines) { + this.lines = lines; + } + + } + +} diff --git a/src/main/java/de/siegmar/fastcsv/writer/CsvAppender.java b/src/main/java/de/siegmar/fastcsv/writer/CsvAppender.java new file mode 100644 index 0000000..b9401d9 --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/writer/CsvAppender.java @@ -0,0 +1,146 @@ +/* + * Copyright 2015 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.writer; + +import java.io.Closeable; +import java.io.Flushable; +import java.io.IOException; +import java.io.Writer; + +/** + * This is the main class for writing CSV data. + * + * @author Oliver Siegmar + */ +public final class CsvAppender implements Closeable, Flushable { + + private static final char LF = '\n'; + private static final char CR = '\r'; + + private final Writer writer; + private final char fieldSeparator; + private final char textDelimiter; + private final boolean alwaysDelimitText; + private final char[] lineDelimiter; + + private boolean newline = true; + + CsvAppender(final Writer writer, final char fieldSeparator, final char textDelimiter, + final boolean alwaysDelimitText, final char[] lineDelimiter) { + this.writer = new FastBufferedWriter(writer); + this.fieldSeparator = fieldSeparator; + this.textDelimiter = textDelimiter; + this.alwaysDelimitText = alwaysDelimitText; + this.lineDelimiter = lineDelimiter; + } + + /** + * Appends a field to the current row. Automatically adds field separator and text delimiters + * as required. + * + * @param value the field to append ({@code null} is handled as empty string) + * @throws IOException if a write error occurs + */ + public void appendField(final String value) throws IOException { + if (!newline) { + writer.write(fieldSeparator); + } else { + newline = false; + } + + if (value == null) { + if (alwaysDelimitText) { + writer.write(textDelimiter); + writer.write(textDelimiter); + } + return; + } + + boolean needsTextDelimiter = alwaysDelimitText; + boolean containsTextDelimiter = false; + + for (int i = 0; i < value.length(); i++) { + final char c = value.charAt(i); + if (c == textDelimiter) { + containsTextDelimiter = needsTextDelimiter = true; + break; + } else if (c == fieldSeparator || c == LF || c == CR) { + needsTextDelimiter = true; + } + } + + if (needsTextDelimiter) { + writer.write(textDelimiter); + } + + if (containsTextDelimiter) { + for (int i = 0; i < value.length(); i++) { + final char c = value.charAt(i); + if (c == textDelimiter) { + writer.write(textDelimiter); + } + writer.write(c); + } + } else { + writer.write(value); + } + + if (needsTextDelimiter) { + writer.write(textDelimiter); + } + } + + /** + * Appends a complete line - one or more fields and new line character(s) at the end. + * + * @param values the fields to append ({@code null} values are handled as empty strings) + * @throws IOException if a write error occurs + */ + public void appendLine(final String... values) throws IOException { + for (final String value : values) { + appendField(value); + } + endLine(); + } + + /** + * Appends new line character(s) to the current line. + * + * @throws IOException if a write error occurs + */ + public void endLine() throws IOException { + writer.write(lineDelimiter); + newline = true; + } + + /** + * {@inheritDoc} + */ + @Override + public void close() throws IOException { + writer.close(); + } + + /** + * {@inheritDoc} + */ + @Override + public void flush() throws IOException { + writer.flush(); + } + +} diff --git a/src/main/java/de/siegmar/fastcsv/writer/CsvWriter.java b/src/main/java/de/siegmar/fastcsv/writer/CsvWriter.java new file mode 100644 index 0000000..da1482d --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/writer/CsvWriter.java @@ -0,0 +1,191 @@ +/* + * Copyright 2015 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.writer; + +import java.io.File; +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.io.Writer; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardOpenOption; +import java.util.Collection; +import java.util.Objects; + +/** + * This is the main class for writing CSV data. + * + * @author Oliver Siegmar + */ +public final class CsvWriter { + + /** + * Field separator character (default: ',' - comma). + */ + private char fieldSeparator = ','; + + /** + * Text delimiter character (default: '"' - double quotes). + */ + private char textDelimiter = '"'; + + /** + * Should fields always delimited using the {@link #textDelimiter}? (default: false). + */ + private boolean alwaysDelimitText; + + /** + * The line delimiter character(s) to be used (default: {@link System#lineSeparator()}). + */ + private char[] lineDelimiter = System.lineSeparator().toCharArray(); + + /** + * Sets the field separator character (default: ',' - comma). + */ + public void setFieldSeparator(final char fieldSeparator) { + this.fieldSeparator = fieldSeparator; + } + + /** + * Sets the text delimiter character (default: '"' - double quotes). + */ + public void setTextDelimiter(final char textDelimiter) { + this.textDelimiter = textDelimiter; + } + + /** + * Sets if fields should always delimited using the {@link #textDelimiter} (default: false). + */ + public void setAlwaysDelimitText(final boolean alwaysDelimitText) { + this.alwaysDelimitText = alwaysDelimitText; + } + + /** + * Sets the line delimiter character(s) to be used (default: {@link System#lineSeparator()}). + */ + public void setLineDelimiter(final char[] lineDelimiter) { + this.lineDelimiter = lineDelimiter.clone(); + } + + /** + * Writes all specified data to the file. + * + * @param file where the data should be written to. + * @param data lines/columns to be written. + * @throws IOException if a write error occurs + * @throws NullPointerException if file, charset or data is null + */ + public void write(final File file, final Charset charset, final Collection data) + throws IOException { + + write( + Objects.requireNonNull(file, "file must not be null").toPath(), + Objects.requireNonNull(charset, "charset must not be null"), + data + ); + } + + /** + * Writes all specified data to the path. + * + * @param path where the data should be written to. + * @param data lines/columns to be written. + * @throws IOException if a write error occurs + * @throws NullPointerException if path, charset or data is null + */ + public void write(final Path path, final Charset charset, final Collection data) + throws IOException { + + Objects.requireNonNull(path, "path must not be null"); + Objects.requireNonNull(charset, "charset must not be null"); + try (final Writer writer = newWriter(path, charset)) { + write(writer, data); + } + } + + /** + * Writes all specified data to the writer. + * + * @param writer where the data should be written to. + * @param data lines/columns to be written. + * @throws IOException if a write error occurs + * @throws NullPointerException if writer or data is null + */ + public void write(final Writer writer, final Collection data) throws IOException { + Objects.requireNonNull(data, "data must not be null"); + final CsvAppender appender = append(writer); + for (final String[] values : data) { + appender.appendLine(values); + } + appender.flush(); + } + + /** + * Constructs a {@link CsvAppender} for the specified File. + * + * @param file the file to write data to. + * @param charset the character set to be used for writing data to the file. + * @return a new CsvAppender instance + * @throws IOException if a write error occurs + * @throws NullPointerException if file or charset is null + */ + public CsvAppender append(final File file, final Charset charset) throws IOException { + return append( + Objects.requireNonNull(file, "file must not be null").toPath(), + Objects.requireNonNull(charset, "charset must not be null") + ); + } + + /** + * Constructs a {@link CsvAppender} for the specified Path. + * + * @param path the Path (file) to write data to. + * @param charset the character set to be used for writing data to the file. + * @return a new CsvAppender instance + * @throws IOException if a write error occurs + * @throws NullPointerException if path or charset is null + */ + public CsvAppender append(final Path path, final Charset charset) throws IOException { + return append(newWriter( + Objects.requireNonNull(path, "path must not be null"), + Objects.requireNonNull(charset, "charset must not be null") + )); + } + + /** + * Constructs a {@link CsvAppender} for the specified Writer. + * + * This library uses built-in buffering, so you do not need to pass in a buffered Writer + * implementation such as {@link java.io.BufferedWriter}. + * Performance may be even likely better if you do not. + * + * @param writer the Writer to use for writing CSV data. + * @return a new CsvAppender instance + * @throws NullPointerException if writer is null + */ + public CsvAppender append(final Writer writer) { + return new CsvAppender(Objects.requireNonNull(writer, "writer must not be null"), + fieldSeparator, textDelimiter, alwaysDelimitText, lineDelimiter); + } + + private static Writer newWriter(final Path path, final Charset charset) throws IOException { + return new OutputStreamWriter(Files.newOutputStream(path, StandardOpenOption.CREATE, + StandardOpenOption.TRUNCATE_EXISTING), charset); + } + +} diff --git a/src/main/java/de/siegmar/fastcsv/writer/FastBufferedWriter.java b/src/main/java/de/siegmar/fastcsv/writer/FastBufferedWriter.java new file mode 100644 index 0000000..bf3805a --- /dev/null +++ b/src/main/java/de/siegmar/fastcsv/writer/FastBufferedWriter.java @@ -0,0 +1,80 @@ +/* + * Copyright 2015 Oliver Siegmar + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package de.siegmar.fastcsv.writer; + +import java.io.IOException; +import java.io.Writer; + +/** + * Unsynchronized and thus high performance replacement for BufferedWriter. + * + * This class is intended for internal use only. + * + * @author Oliver Siegmar + */ +final class FastBufferedWriter extends Writer { + + private static final int BUFFER_SIZE = 8192; + + private Writer out; + private char[] buf = new char[BUFFER_SIZE]; + private int pos; + + FastBufferedWriter(final Writer writer) { + this.out = writer; + } + + @Override + public void write(final char[] cbuf, final int off, final int len) throws IOException { + if (pos + len >= buf.length) { + flushBuffer(); + } + + if (len >= buf.length) { + out.write(cbuf, off, len); + } else { + System.arraycopy(cbuf, off, buf, pos, len); + pos += len; + } + } + + @Override + public void write(final int c) throws IOException { + if (pos == buf.length) { + flushBuffer(); + } + buf[pos++] = (char) c; + } + + @Override + public void close() throws IOException { + flushBuffer(); + out.close(); + } + + @Override + public void flush() throws IOException { + flushBuffer(); + out.flush(); + } + + private void flushBuffer() throws IOException { + out.write(buf, 0, pos); + pos = 0; + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 5e5b0f1..2867300 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -88,8 +88,6 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { Connection connect = getConnection(); DBGitLang lang = DBGitLang.getInstance(); - IMapMetaObject currStep = updateObjs; - try { List tables = new ArrayList(); List tablesData = new ArrayList(); diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java index 854dfe4..f3bbd08 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java @@ -4,6 +4,7 @@ import java.io.FileOutputStream; import java.io.OutputStreamWriter; import java.sql.Timestamp; +import java.util.HashSet; import java.util.Set; import org.apache.commons.cli.CommandLine; @@ -124,7 +125,8 @@ public void execute(CommandLine cmdLine) throws Exception { for (RowData rd : gmdm.getCurrent().getmapRows().values()) { if (count == 0 && isFirstPortion) { - fields = rd.getData().keySet(); + //fields = rd.getData().keySet(); + fields = new HashSet<>(gmdm.getCurrent().getFields()); csvPrinter.printRecord(fields); isFirstPortion = false; } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java index 435cd21..249dd42 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java @@ -166,7 +166,7 @@ public static boolean createDefaultDbgitConfig(String path) throws ExceptionDBGi writer.write("LOG_ROTATE = 31\n"); writer.write("LANG = ENG\n"); writer.write("SCRIPT_ROTATE = 31\n"); - writer.write("TO_MAKE_BACKUP = true\n"); + writer.write("TO_MAKE_BACKUP = false\n"); writer.write("BACKUP_TO_SCHEME = false\n"); writer.write("BACKUP_TABLEDATA = true\n"); writer.write("PORTION_SIZE = 50000\n"); diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/BooleanData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/BooleanData.java index cc62bb8..f07d46c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/BooleanData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/BooleanData.java @@ -7,13 +7,14 @@ public class BooleanData implements ICellData { - private Boolean value; + private boolean value; + private boolean isNull = false; @Override - public boolean loadFromDB(ResultSet rs, String fieldname) throws Exception { - value = rs.getBoolean(fieldname); + public boolean loadFromDB(ResultSet rs, String fieldName) throws Exception { + value = rs.getBoolean(fieldName); if (rs.wasNull()) { - value = null; + isNull = true; } return true; } @@ -25,7 +26,14 @@ public String serialize(DBTable tbl) throws Exception { @Override public void deserialize(String data) throws Exception { - this.value = (data == null) ? null : Boolean.valueOf(data); + //this.value = (data == null) ? null : Boolean.valueOf(data); + if (data == null) { + isNull = true; + value = false; + } else { + isNull = false; + value = Boolean.parseBoolean(data); + } } @Override @@ -40,7 +48,7 @@ public int removeFromGit() throws ExceptionDBGit { @Override public String convertToString() throws Exception { - return value != null ? value.toString() : null; + return !isNull ? String.valueOf(value) : null; } @Override @@ -49,12 +57,13 @@ public Object getWriterForRapair() { } public Boolean getValue() { + if (isNull) return null; return value; } @Override public String getSQLData() { - return (value == null) ? "''" : "\'"+value.toString()+"\'"; + return (isNull) ? "''" : "\'"+String.valueOf(value)+"\'"; } } diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/DateData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/DateData.java index 0aaa665..095d34e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/DateData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/DateData.java @@ -10,27 +10,41 @@ import ru.fusionsoft.dbgit.utils.Convertor; public class DateData implements ICellData { - Date value; - SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); + //private Date value; + private long value; + private boolean isNull = false; + public static SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); @Override public boolean loadFromDB(ResultSet rs, String fieldname) throws Exception { - value = rs.getDate(fieldname); + if (rs.getDate(fieldname) == null) { + isNull = true; + value = 0; + } else + value = rs.getDate(fieldname).getTime(); + return true; } @Override public String serialize(DBTable tbl) throws Exception { - return value == null ? null : format.format(value); + return isNull ? null : format.format(new Date(value)); } @Override public void deserialize(String data) throws Exception { - value = (data == null) ? null :new Date(format.parse(data).getTime()); + //value = (data == null) ? null :new Date(format.parse(data).getTime()); + if (data == null) { + isNull = true; + value = 0; + } else { + isNull = false; + value = format.parse(data).getTime(); + } } public void setValue(Date value) { - this.value = value; + this.value = value.getTime(); } @Override @@ -45,7 +59,7 @@ public int removeFromGit() throws ExceptionDBGit { @Override public String convertToString() throws Exception { - return (value == null) ? null : format.format(value); + return isNull ? null : format.format(new Date(value)); } @Override @@ -55,11 +69,11 @@ public Object getWriterForRapair() { @Override public String getSQLData() { - return (value == null) ? "''" : "\'"+format.format(value)+"\'"; + return isNull ? "''" : "\'"+format.format(new Date(value))+"\'"; } public Date getDate() { - return value; + return new Date(value); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/LongData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/LongData.java index 2bab5bf..0e04dd0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/LongData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/LongData.java @@ -6,13 +6,14 @@ public class LongData implements ICellData { - private Long value; + private double value; + private boolean isNull = false; @Override public boolean loadFromDB(ResultSet rs, String fieldname) throws Exception { - value = rs.getLong(fieldname); + value = rs.getDouble(fieldname); if (rs.wasNull()) { - value = null; + isNull = true; } return true; } @@ -24,7 +25,14 @@ public String serialize(DBTable tbl) throws Exception { @Override public void deserialize(String data) throws Exception { - this.value = (data == null) ? null : Long.decode(data); + if (data == null) { + isNull = true; + value = 0; + } else { + isNull = false; + value = Double.parseDouble(data); + } + //this.value = (data == null) ? null : Long.decode(data); //this.value = Long.decode(data); /* try { @@ -37,14 +45,14 @@ public void deserialize(String data) throws Exception { @Override public String convertToString() { - return value != null ? value.toString() : null; + return !isNull ? String.valueOf(value) : null; } - public Long getValue() { + public double getValue() { return value; } - public void setValue(Long value) { + public void setValue(double value) { this.value = value; } @@ -62,7 +70,10 @@ public int removeFromGit() { @Override public String getSQLData() { - return (value == null) ? "''" : "\'"+value.toString()+"\'"; + return (isNull) ? "''" : "\'"+String.valueOf(value)+"\'"; + } + + public boolean isNull() { + return isNull; } - } diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java index 32f6b1d..7930114 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java @@ -18,7 +18,7 @@ public class MapFileData implements ICellData { private String srcFile = null; private File tmpFile = null; - private String hash = null; + //private String hash = null; public InputStream getBlobData(ResultSet rs, String fieldname) throws Exception { return rs.getBinaryStream(fieldname); @@ -68,7 +68,8 @@ public Object getWriterForRapair() { } public String getHash() throws Exception { - if (hash == null) { + //if (hash == null) { + String hash; String path = null; if (tmpFile != null) path = tmpFile.getAbsolutePath(); if (srcFile != null) path = DBGitPath.getFullPath()+"/"+srcFile; @@ -78,7 +79,7 @@ public String getHash() throws Exception { CalcHash ch = new CalcHash(); ch.addDataFile(path); hash = ch.calcHashStr(); - } + //} return hash; } diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java index eb68e56..8a72cd5 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java @@ -2,13 +2,9 @@ import java.io.IOException; import java.sql.ResultSet; -import java.util.HashMap; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.TreeMap; +import java.util.*; +import de.siegmar.fastcsv.reader.CsvRow; import org.apache.commons.csv.CSVPrinter; import org.apache.commons.csv.CSVRecord; @@ -21,40 +17,70 @@ import ru.fusionsoft.dbgit.utils.ConsoleWriter; public class RowData { - protected Map data = new LinkedHashMap<>(); - protected String hashRow; - protected String key; - protected MetaTable metaTable; - + //protected Map data = new LinkedHashMap<>(); + private List rowList = new ArrayList<>(); + private String hashRow; + //protected String key; + //protected MetaTable metaTable; + public RowData(ResultSet rs, MetaTable metaTable) throws Exception { - this.metaTable = metaTable; - loadDataFromRS(rs); + //this.metaTable = metaTable; + loadDataFromRS(rs, metaTable); } - + + public RowData(CsvRow record, MetaTable metaTable, CsvRow titleColumns) throws Exception { + //this.metaTable = metaTable; + loadDataFromCSVRecord(record, titleColumns, metaTable); + } + public RowData(CSVRecord record, MetaTable metaTable, CSVRecord titleColumns) throws Exception { - this.metaTable = metaTable; - loadDataFromCSVRecord(record, titleColumns); + //this.metaTable = metaTable; + loadDataFromCSVRecord(record, titleColumns, metaTable); } - - public void loadDataFromRS(ResultSet rs) throws Exception { - for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) { + + public void loadDataFromRS(ResultSet rs, MetaTable metaTable) throws Exception { + for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) { String columnName = rs.getMetaData().getColumnName(i+1); if (columnName.equalsIgnoreCase("DBGIT_ROW_NUM")) continue; - + ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); - + if (cd.loadFromDB(rs, rs.getMetaData().getColumnName(i+1))) - data.put(columnName, cd); + rowList.add(cd); + //data.put(columnName, cd); } - hashRow = calcRowHash(); - - key = calcRowKey(metaTable.getIdColumns()); + hashRow = calcRowHash().substring(0, 24); + + //key = calcRowKey(metaTable.getIdColumns()); + } + + private void loadDataFromCSVRecord(CsvRow record, CsvRow titleColumns, MetaTable metaTable) throws Exception { + if (record.getFieldCount() != titleColumns.getFieldCount()) { + throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "dataTable", "differentCount")); + } + + for (int i = 0; i < record.getFieldCount(); i++) { + String columnName = titleColumns.getField(i); + if (metaTable.getFieldsMap().get(columnName) == null) { + throw new ExceptionDBGitRunTime(DBGitLang.getInstance().getValue("errors", "dataTable", "fieldNotFound").withParams(columnName)); + } + + ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); + cd.deserialize(record.getField(i).equals("") ? null : record.getField(i)); + + rowList.add(cd); + //data.put(columnName, cd); + } + hashRow = calcRowHash().substring(0, 24); + + //key = calcRowKey(metaTable.getIdColumns()); + } - - public void loadDataFromCSVRecord(CSVRecord record, CSVRecord titleColumns) throws Exception { + + private void loadDataFromCSVRecord(CSVRecord record, CSVRecord titleColumns, MetaTable metaTable) throws Exception { if (record.size() != titleColumns.size()) { throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "dataTable", "differentCount")); @@ -68,21 +94,23 @@ public void loadDataFromCSVRecord(CSVRecord record, CSVRecord titleColumns) thro ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); cd.deserialize(record.get(i)); - - data.put(columnName, cd); + + rowList.add(cd); + //data.put(columnName, cd); } - hashRow = calcRowHash(); + hashRow = calcRowHash().substring(0, 24); - key = calcRowKey(metaTable.getIdColumns()); + //key = calcRowKey(metaTable.getIdColumns()); } public void saveDataToCsv(CSVPrinter csvPrinter, DBTable tbl) throws Exception { - for (ICellData cd : getData().values()) + //for (ICellData cd : getData().values()) + for (ICellData cd : rowList) csvPrinter.print(cd.serialize(tbl)); csvPrinter.println(); } - + /* public String calcRowKey(List idColumns) throws Exception { if (idColumns.size() > 0) { StringBuilder keyBuilder = new StringBuilder(); @@ -94,10 +122,26 @@ public String calcRowKey(List idColumns) throws Exception { return hashRow; } } - + */ + public String calcRowKey(List idColumns) throws Exception { + return hashRow; + /* + if (idColumns.size() > 0) { + StringBuilder keyBuilder = new StringBuilder(); + for (Integer nmId : idColumns) { + keyBuilder.append(rowList.get(nmId).convertToString()+"_"); + } + return keyBuilder.toString(); + } else { + return hashRow; + }*/ + } + + public String calcRowHash() throws Exception { CalcHash ch = new CalcHash(); - for (ICellData cd : data.values()) { + //for (ICellData cd : data.values()) { + for (ICellData cd : rowList) { String str = cd.convertToString(); if ( str != null) ch.addData(str); @@ -105,8 +149,32 @@ public String calcRowHash() throws Exception { return ch.calcHashStr(); } - public Map getData() { - return data; + public Map getData(List fields) { + Map res = new LinkedHashMap<>(); + + int i = 0; + for (ICellData cd : rowList) { + res.put(fields.get(i), cd); + i++; + } + + return res; + } + + public Map getData() { + Map res = new HashMap<>(); + + int i = 0; + for (ICellData cd : rowList) { + res.put(String.valueOf(i), cd); + i++; + } + + return res; + } + + public List getListData() { + return rowList; } public String getHashRow() { @@ -114,11 +182,8 @@ public String getHashRow() { } public String getKey() { - return key; - } - - public MetaTable getMetaTable() { - return metaTable; + //return key; + return hashRow; } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java index 379ebd7..eb9cc3f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java @@ -78,45 +78,49 @@ public interface IMetaObject { * @throws IOException */ public IMetaObject deSerialize(InputStream stream) throws Exception; - + + public default IMetaObject deSerialize(File file) throws Exception { + return this; + }; + /** * load current object from DB */ public boolean loadFromDB() throws ExceptionDBGit; - + public String getHash(); - + /** * Save meta file to base path * Example - .dbgit/basePath/path_and_filename_meta_object - * + * * @param basePath * @throws IOException */ default boolean saveToFile(String basePath) throws ExceptionDBGit { File file = new File(DBGitPath.getFullPath(basePath)+"/"+getFileName()); DBGitPath.createDir(file.getParent()); - + try { FileOutputStream out = new FileOutputStream(file.getAbsolutePath()); boolean res = this.serialize(out); out.close(); - + return res; } catch (Exception e) { e.printStackTrace(); throw new ExceptionDBGit(e); } } - + default boolean saveToFile() throws ExceptionDBGit { return saveToFile(null); } - + /** * Load meta file to base path * Example - .dbgit/basePath/path_and_filename_meta_object - * + * * @param basePath * @throws IOException */ @@ -124,7 +128,11 @@ default IMetaObject loadFromFile(String basePath) throws Exception { String filename = DBGitPath.getFullPath(basePath); File file = new File(filename+"/"+getFileName()); FileInputStream fis = new FileInputStream(file); - IMetaObject meta = this.deSerialize(fis); + IMetaObject meta; + if (!file.getPath().endsWith(".csv")) + meta = this.deSerialize(fis); + else + meta = this.deSerialize(file); fis.close(); if (meta != null && meta.getName().isEmpty()) { meta.setName(this.getName()); diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaFunction.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaFunction.java index 9823362..66eff5f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaFunction.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaFunction.java @@ -11,7 +11,7 @@ public class MetaFunction extends MetaSql { public MetaFunction() { super(); } - + public MetaFunction(DBFunction fun) throws ExceptionDBGit { super(fun); } @@ -29,6 +29,9 @@ public String getName() { @Override public String getFileName(){ String res = name.replace(".fnc", ""); + String schemaName = ""; + if (res.contains("/")) + schemaName = res.substring(0, res.indexOf("/")); if (this.getSqlObject() != null && this.getSqlObject().getOptions() != null && this.getSqlObject().getOptions().get("arguments") != null) res = res + "_" + this.getSqlObject().getOptions().get("arguments").getData() @@ -41,7 +44,7 @@ public String getFileName(){ .replace("::", ""); if (res.endsWith("_")) res = res.substring(0, res.length() - 1); - if (res.length() > MAX_FILE_NAME_LENGTH) { + if (res.length() > (schemaName.length() + 1 + MAX_FILE_NAME_LENGTH)) { String resTemp = res.substring(0, MAX_FILE_NAME_LENGTH); int resInt = res.length() - MAX_FILE_NAME_LENGTH; res = resTemp + "_" + resInt; @@ -51,7 +54,7 @@ public String getFileName(){ return res; } - + @Override public boolean loadFromDB() throws ExceptionDBGit { IDBAdapter adapter = AdapterFactory.createAdapter(); diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaProcedure.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaProcedure.java index 7335917..46a8a61 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaProcedure.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaProcedure.java @@ -29,6 +29,9 @@ public String getName() { @Override public String getFileName(){ String res = name.replace(".prc", ""); + String schemaName = ""; + if (res.contains("/")) + schemaName = res.substring(0, res.indexOf("/")); if (this.getSqlObject() != null && this.getSqlObject().getOptions() != null && this.getSqlObject().getOptions().get("arguments") != null) res = res + "_" + this.getSqlObject().getOptions().get("arguments").getData() @@ -41,7 +44,7 @@ public String getFileName(){ .replace("::", ""); if (res.endsWith("_")) res = res.substring(0, res.length() - 1); - if (res.length() > MAX_FILE_NAME_LENGTH) { + if (res.length() > (schemaName.length() + 1 + MAX_FILE_NAME_LENGTH)) { String resTemp = res.substring(0, MAX_FILE_NAME_LENGTH); int resInt = res.length() - MAX_FILE_NAME_LENGTH; res = resTemp + "_" + resInt; diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java index 96bbcb1..755c203 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java @@ -23,43 +23,43 @@ import ru.fusionsoft.dbgit.yaml.YamlOrder; /** - * Meta class for db Table + * Meta class for db Table * @author mikle * */ -public class MetaTable extends MetaBase { +public class MetaTable extends MetaBase { @YamlOrder(1) private DBTable table; - + @YamlOrder(2) //private IMapFields fields = new TreeMapFields(); private Map fields = new TreeMap<>(); - + @YamlOrder(3) private Map indexes = new TreeMap<>(); - + @YamlOrder(4) private Map constraints = new TreeMap<>(); - public MetaTable() { + public MetaTable() { setDbType(); setDbVersion(); } - + public MetaTable(String namePath) { setDbType(); setDbVersion(); this.name = namePath; } - + public MetaTable(DBTable tbl) { setDbType(); setDbVersion(); setTable(tbl); } - + @Override public DBGitMetaType getType() { return DBGitMetaType.DBGitTable; @@ -213,13 +213,16 @@ public void setConstraints(Map constraints) { this.constraints.putAll(constraints); } - public List getIdColumns() { - List idColumns = new ArrayList<>(); - + public List getIdColumns() { + List idColumns = new ArrayList<>(); + + int i = 0; for (DBTableField field : fields.values()) { if (field.getIsPrimaryKey()) { - idColumns.add(field.getName()); + //idColumns.add(field.getName()); + idColumns.add(i); } + i++; } return idColumns; diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index 34f4400..197025a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -1,10 +1,8 @@ package ru.fusionsoft.dbgit.meta; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.io.OutputStream; -import java.io.OutputStreamWriter; +import java.io.*; import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.sql.ResultSet; import java.util.ArrayList; import java.util.Iterator; @@ -14,11 +12,16 @@ import java.util.TreeMap; import java.util.concurrent.TimeUnit; +import de.siegmar.fastcsv.reader.CsvParser; +import de.siegmar.fastcsv.reader.CsvReader; +import de.siegmar.fastcsv.reader.CsvRow; import org.apache.commons.codec.binary.Base64; + import org.apache.commons.csv.CSVFormat; import org.apache.commons.csv.CSVParser; import org.apache.commons.csv.CSVPrinter; import org.apache.commons.csv.CSVRecord; + import org.apache.commons.csv.QuoteMode; import com.diogonunes.jcdp.color.api.Ansi.FColor; @@ -48,21 +51,22 @@ public class MetaTableData extends MetaBase { protected DBTable table = null; private DBTableData dataTable = null; - + private TreeMapRowData mapRows = null; + private List fields = new ArrayList<>(); public MetaTableData() { setDbType(); setDbVersion(); } - + public MetaTableData(DBTable tbl) throws ExceptionDBGit { setDbType(); setDbVersion(); setTable(tbl); } - - + + public DBTable getTable() { return table; } @@ -70,26 +74,26 @@ public DBTable getTable() { public TreeMap getmapRows() { return mapRows; } - + public DBTableData getDataTable() { return dataTable; } - + public void setMapRows(TreeMapRowData mapRows) { this.mapRows = mapRows; } - + public void setDataTable(DBTableData dataTable) { this.dataTable = dataTable; } - + public void setTable(DBTable table) throws ExceptionDBGit { this.table = table; setName(table.getSchema()+"/"+table.getName()+"."+getType().getValue()); } - - + + @Override public void setName(String name) throws ExceptionDBGit { if (table == null) { @@ -98,7 +102,7 @@ public void setName(String name) throws ExceptionDBGit { table.setSchema(nm.getSchema()); table.setName(nm.getName()); } - + super.setName(name); } @@ -114,13 +118,13 @@ public CSVFormat getCSVFormat() { .withNullString("") .withQuote('"') //.withQuoteMode(QuoteMode.ALL) - ; + ; } - + public MetaTable getMetaTable() throws ExceptionDBGit { String metaTblName = table.getSchema()+"/"+table.getName()+"."+DBGitMetaType.DBGitTable.getValue(); GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); - + IMapMetaObject dbObjs = gmdm.getCacheDBMetaData(); MetaTable metaTable = (MetaTable) dbObjs.get(metaTblName); if (metaTable == null ) { @@ -129,63 +133,102 @@ public MetaTable getMetaTable() throws ExceptionDBGit { } return metaTable; } - + public MetaTable getMetaTableFromFile() throws ExceptionDBGit { String metaTblName = table.getSchema()+"/"+table.getName()+"."+DBGitMetaType.DBGitTable.getValue(); GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); - - MetaTable metaTable = (MetaTable)gmdm.loadMetaFile(metaTblName); - if (metaTable != null) + + MetaTable metaTable = (MetaTable)gmdm.loadMetaFile(metaTblName); + if (metaTable != null) return metaTable; - + return getMetaTable(); } - - + + @Override public boolean serialize(OutputStream stream) throws Exception { Integer count = 0; Set fields = null; - + if (mapRows == null) { return false; } - + CSVPrinter csvPrinter = new CSVPrinter(new OutputStreamWriter(stream), getCSVFormat()); - + for (RowData rd : mapRows.values()) { if (count == 0) { - fields = rd.getData().keySet(); - csvPrinter.printRecord(fields); + fields = rd.getData(this.fields).keySet(); + csvPrinter.printRecord(fields); } - + rd.saveDataToCsv(csvPrinter, getTable()); - + count++; } csvPrinter.close(); return true; } + @Override + public IMetaObject deSerialize(File file) throws Exception { + MetaTable metaTable = getMetaTableFromFile(); + + CsvReader csvReader = new CsvReader(); + csvReader.setFieldSeparator(';'); + + try (CsvParser csvParser = csvReader.parse(file, StandardCharsets.UTF_8)) { + CsvRow row; + boolean flag = false; + mapRows = new TreeMapRowData(); + CsvRow titleColumns = null; + int i = 1; + + + while ((row = csvParser.nextRow()) != null) { + if (!flag) { + titleColumns = row; + fields = row.getFields(); + } else { + RowData rd = new RowData(row, metaTable, titleColumns); + mapRows.put(rd); + ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("general", "meta", "loadRow") + ": "+ i); + System.out.println("row: " + i); + i++; + } + flag = true; + } + } + System.out.println("TableData loaded!"); + return this; + } + + @Override public IMetaObject deSerialize(InputStream stream) throws Exception { - - MetaTable metaTable = getMetaTableFromFile(); - + + MetaTable metaTable = getMetaTableFromFile(); + CSVParser csvParser = new CSVParser(new InputStreamReader(stream), getCSVFormat()); - List csvRecords = csvParser.getRecords(); - + List csvRecords = csvParser.getRecords(); + if (csvRecords.size() > 0) { CSVRecord titleColumns = csvRecords.get(0); - + fields.clear(); + for (int i = 0; i < csvRecords.get(0).size(); i++) { + fields.add(csvRecords.get(0).get(i)); + } + mapRows = new TreeMapRowData(); for (int i = 1; i < csvRecords.size(); i++) { RowData rd = new RowData(csvRecords.get(i), metaTable, titleColumns); - mapRows.put(rd); + mapRows.put(rd); } } + csvParser.close(); //saveToFile("test"); @@ -214,12 +257,28 @@ public boolean loadPortionFromDB(int currentPortionIndex, int tryNumber) throws return false; } - mapRows = new TreeMapRowData(); - + mapRows = new TreeMapRowData(); + + boolean flag = false; while(rs.next()){ + + if (!flag) { + fields.clear(); + for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) { + String columnName = rs.getMetaData().getColumnName(i + 1); + if (columnName.equalsIgnoreCase("DBGIT_ROW_NUM")) + continue; + fields.add(columnName); + } + } + + flag = true; RowData rd = new RowData(rs, metaTable); mapRows.put(rd); } + + + return true; } catch (Exception e) { e.printStackTrace(); @@ -256,8 +315,6 @@ public boolean loadFromDB() throws ExceptionDBGit { if (metaTable.getFields().size() == 0) return false; - - List idColumns = metaTable.getIdColumns(); dataTable = adapter.getTableData(table.getSchema(), table.getName()); @@ -299,20 +356,20 @@ public void diff(MetaTableData ob) throws Exception { RowData r2 = ob.mapRows.get(rowHash); System.out.println(rowHash); - System.out.println(r1.getData()+ " "+ r2.getData()); + System.out.println(r1.getData(fields)+ " "+ r2.getData(ob.fields)); - if (r1.getData().size() != r2.getData().size()) { + if (r1.getData(fields).size() != r2.getData(ob.fields).size()) { System.out.println(DBGitLang.getInstance().getValue("general", "meta", "diffSize2").withParams(rowHash)); } - for (String col : r1.getData().keySet()) { - String d1 = r1.getData().get(col).convertToString(); - String d2 = r2.getData().get(col).convertToString(); + for (String col : r1.getData(fields).keySet()) { + String d1 = r1.getData(fields).get(col).convertToString(); + String d2 = r2.getData(ob.fields).get(col).convertToString(); if (d1 != d2) { - if (!d1.equals(r2.getData().get(col))) { + if (!d1.equals(r2.getData(ob.fields).get(col))) { System.out.println(DBGitLang.getInstance().getValue("general", "meta", "diffDataRow"). - withParams(rowHash, col, r1.getData().get(col).toString(), r2.getData().get(col).toString())); + withParams(rowHash, col, r1.getData(fields).get(col).toString(), r2.getData(ob.fields).get(col).toString())); } } } @@ -347,7 +404,7 @@ public int addToGit() throws ExceptionDBGit { if (mapRows == null) return count; for (RowData rd : mapRows.values()) { - for (ICellData cd : rd.getData().values()) { + for (ICellData cd : rd.getData(fields).values()) { count += cd.addToGit(); } } @@ -363,7 +420,7 @@ public int removeFromGit() throws ExceptionDBGit { return 1; for (RowData rd : mapRows.values()) { - for (ICellData cd : rd.getData().values()) { + for (ICellData cd : rd.getData(fields).values()) { count += cd.removeFromGit(); } } @@ -371,4 +428,7 @@ public int removeFromGit() throws ExceptionDBGit { return count; } + public List getFields() { + return fields; + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java index c1697ed..4bcc280 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java @@ -231,7 +231,7 @@ private static String valueToString(ICellData cell) { if(cell instanceof BooleanData) value += ((BooleanData) cell).getValue(); else if(cell instanceof LongData) - value += ((LongData) cell).getValue() != null ? String.valueOf(((LongData) cell).getValue()) : ""; + value += !((LongData) cell).isNull() ? String.valueOf(((LongData) cell).getValue()) : ""; else if(cell instanceof StringData) value += ((StringData) cell).getValue() != null ? ("'" + ((StringData) cell).getValue() .replace("\\", "\\\\") diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index 44a70df..68eb31d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -17,13 +17,6 @@ import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.core.db.FieldType; -import ru.fusionsoft.dbgit.data_table.MapFileData; -import ru.fusionsoft.dbgit.data_table.BooleanData; -import ru.fusionsoft.dbgit.data_table.DateData; -import ru.fusionsoft.dbgit.data_table.FactoryCellData; -import ru.fusionsoft.dbgit.data_table.LongData; -import ru.fusionsoft.dbgit.data_table.StringData; -import ru.fusionsoft.dbgit.data_table.TextFileData; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; import ru.fusionsoft.dbgit.dbobjects.DBFunction; import ru.fusionsoft.dbgit.dbobjects.DBIndex; @@ -360,7 +353,7 @@ public Map getTableFields(String schema, String nameTable } } - protected String getFieldType(ResultSet rs) { + private String getFieldType(ResultSet rs) { try { StringBuilder type = new StringBuilder(); type.append(rs.getString("dtype")); @@ -495,6 +488,7 @@ public Map getViews(String schema) { "join pg_roles rol on rol.oid = cls.relowner \n" + "join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + "where nsp.nspname not in ('information_schema', 'pg_catalog') \n" + + "and cls.relname not in ('pg_buffercache', 'pg_stat_statements') \n" + "and nsp.nspname not like 'pg_toast%' \n" + "and cls.relkind = 'v' \n" + "and nsp.nspname = '"+schema+"' \n"; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index 39562f2..296afe7 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -145,6 +145,8 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa } + List fieldsList = restoreTableData.getFields(); + MapDifference diffTableData = Maps.difference(restoreTableData.getmapRows(),currentTableData.getmapRows()); String schema = getPhisicalSchema(restoreTableData.getTable().getSchema()); @@ -168,37 +170,15 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 2); for(RowData rowData:diffTableData.entriesOnlyOnLeft().values()) { - ArrayList fieldsList = new ArrayList(rowData.getData().keySet().stream().map(DBAdapterPostgres::escapeNameIfNeeded).collect(Collectors.toList())); + //ArrayList fieldsList = new ArrayList(rowData.getData().keySet().stream().map(DBAdapterPostgres::escapeNameIfNeeded).collect(Collectors.toList())); String insertQuery = "insert into " + tblNameEscaped + - fields+valuesToString(rowData.getData().values(), colTypes, fieldsList) + ";\n"; + fields+valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) + ";\n"; ConsoleWriter.detailsPrintLn(insertQuery); PrepareStatementLogging ps = new PrepareStatementLogging(connect, insertQuery, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - int i = 0; - - for (ICellData data : rowData.getData().values()) { - i++; - ConsoleWriter.detailsPrintLn(data.getSQLData()); - - ResultSet rs = st.executeQuery("select data_type from information_schema.columns \r\n" + - "where lower(table_schema||'.'||table_name) = lower('" + tblNameUnescaped + "') and lower(column_name) = '" + fieldsList.get(i - 1) + "'"); - - boolean isBoolean = false; - while (rs.next()) { - if (rs.getString("data_type").contains("boolean")) { - isBoolean = true; - } - } - //ps = setValues(data, i, ps, isBoolean); - } - - //if (adapter.isExecSql()) - // ps.execute(); - //ps.close(); - st.execute(insertQuery); } ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); @@ -209,7 +189,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa String deleteQuery=""; Map primarykeys = new HashMap(); for(RowData rowData:diffTableData.entriesOnlyOnRight().values()) { - Map tempcols = rowData.getData(); + Map tempcols = rowData.getData(fieldsList); String[] keysArray = rowData.getKey().split("_"); for(String key:keysArray) { for (String o : tempcols.keySet()) { @@ -252,7 +232,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa Map primarykeys = new HashMap(); for(ValueDifference diffRowData:diffTableData.entriesDiffering().values()) { if(!diffRowData.leftValue().getHashRow().equals(diffRowData.rightValue().getHashRow())) { - Map tempCols = diffRowData.leftValue().getData(); + Map tempCols = diffRowData.leftValue().getData(fieldsList); String[] keysArray = diffRowData.leftValue().getKey().split("_"); for(String key:keysArray) { for (String o : tempCols.keySet()) { @@ -288,7 +268,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa //updvaluejoiner.add("?"); } - ArrayList fieldsList = new ArrayList(diffRowData.leftValue().getData().keySet()); + //ArrayList fieldsList = new ArrayList(diffRowData.leftValue().getData().keySet()); updFields+=updfieldJoiner.toString()+")"; updValues+=updvaluejoiner.toString()+")"; @@ -299,33 +279,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa ConsoleWriter.detailsPrintLn(updateQuery); PrepareStatementLogging ps = new PrepareStatementLogging(connect, updateQuery, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - int i = 0; - - ConsoleWriter.detailsPrintLn("vals for " + keyValues + ":" + diffRowData.leftValue().getData().values()); - for (ICellData data : diffRowData.leftValue().getData().values()) { - i++; - ConsoleWriter.detailsPrintLn(data.getSQLData()); - - ResultSet rs = st.executeQuery("select data_type from information_schema.columns \r\n" + - "where lower(table_schema||'.'||table_name) = lower('" + tblNameUnescaped + "') and lower(column_name) = '" + fieldsList.get(i - 1) + "'"); - - boolean isBoolean = false; - while (rs.next()) { - if (rs.getString("data_type").toLowerCase().contains("boolean")) { - isBoolean = true; - } - } - //ps = setValues(data, i, ps, isBoolean); - } - /* - if (adapter.isExecSql()) - ps.execute(); - ps.close(); - updateQuery = ""; - */ - - - + //if(updateQuery.length() > 50000 ){ st.execute(updateQuery); updateQuery = ""; @@ -350,7 +304,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa } } - public String valuesToString(Collection datas, HashMap colTypes, ArrayList fieldsList) throws ExceptionDBGit, IOException { + public String valuesToString(Collection datas, HashMap colTypes, List fieldsList) throws ExceptionDBGit, IOException { String values="("; StringJoiner joiner = new StringJoiner(","); int i = 0; diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index b26595b..200b173 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -113,6 +113,7 @@ general: diffSize1: MetaTableData diff size!!! {0} {1} diffSize2: MetaTableData diff size row {0}!!! diffDataRow: MetaTableData diff data row {0} {1} {2} {3} + loadRow: Loading row backup: tryingToCopy: Trying to copy {0} to {1}... creatingSchema: Creating schema {0} From 48d282861539930bbf05e061ab3f1127d86d2168 Mon Sep 17 00:00:00 2001 From: dirak Date: Wed, 12 Aug 2020 13:22:51 +0300 Subject: [PATCH 03/68] Backup adapter fix --- src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java index 9ece220..0aa4d35 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java @@ -67,7 +67,7 @@ public void backupDatabase(IMapMetaObject backupObjs) throws Exception { // collect yet existing backups of restore objects Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); StatementLogging stLog = new StatementLogging(adapter.getConnection(), adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - IMapMetaObject dbObjs = GitMetaDataManager.getInstance().loadDBMetaData(false); + IMapMetaObject dbObjs = GitMetaDataManager.getInstance().loadDBMetaData(true); IMapMetaObject backupList = new TreeMapMetaObject(dbObjs.values().stream() .filter( x-> backupObjs.containsKey(x.getName()) ) From bec5d59696ca27d35d9146f23b276375c1ca7a07 Mon Sep 17 00:00:00 2001 From: rocket Date: Sat, 15 Aug 2020 16:42:39 +0300 Subject: [PATCH 04/68] Change pg text handling from TextData to StringData Fix stack depth error in restore big text cells Fix column order in csv writer Fix sequence restore script spaces --- src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java | 1 + src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java | 7 +++---- src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java | 2 +- .../ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java | 1 + .../dbgit/postgres/DBRestoreSequencePostgres.java | 4 ++-- .../dbgit/postgres/DBRestoreTableDataPostgres.java | 2 +- 6 files changed, 9 insertions(+), 8 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 4923750..8132d6a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -200,6 +200,7 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { */ connect.commit(); } catch (Exception e) { + //TODO wont work with ExceptionDBGit*, cause they call System.exit(1) in ctor; connect.rollback(); ConsoleWriter.detailsPrintlnRed(e.getLocalizedMessage()); e.printStackTrace(); diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java index f3bbd08..9e60cee 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java @@ -4,8 +4,7 @@ import java.io.FileOutputStream; import java.io.OutputStreamWriter; import java.sql.Timestamp; -import java.util.HashSet; -import java.util.Set; +import java.util.List; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.Options; @@ -121,12 +120,12 @@ public void execute(CommandLine cmdLine) throws Exception { try { //gmdm.getCurrent().serialize(out); Integer count = 0; - Set fields = null; + List fields = null; for (RowData rd : gmdm.getCurrent().getmapRows().values()) { if (count == 0 && isFirstPortion) { //fields = rd.getData().keySet(); - fields = new HashSet<>(gmdm.getCurrent().getFields()); + fields = gmdm.getCurrent().getFields(); csvPrinter.printRecord(fields); isFirstPortion = false; } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index 197025a..93943fd 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -194,7 +194,7 @@ public IMetaObject deSerialize(File file) throws Exception { RowData rd = new RowData(row, metaTable, titleColumns); mapRows.put(rd); ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("general", "meta", "loadRow") + ": "+ i); - System.out.println("row: " + i); +// System.out.println("row: " + i); i++; } flag = true; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index d000d18..331d257 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -335,6 +335,7 @@ public Map getTableFields(String schema, String nameTable field.setTypeSQL(typeSQL); field.setIsNullable( !typeSQL.toLowerCase().contains("not null")); field.setTypeUniversal(FieldType.fromString(rs.getString("tp"))); + if(field.getTypeUniversal() == FieldType.TEXT) field.setTypeUniversal(FieldType.STRING); field.setFixed(false); field.setLength(rs.getInt("character_maximum_length")); field.setPrecision(rs.getInt("numeric_precision")); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java index 7fd26c2..7880d2c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java @@ -84,12 +84,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { query+="create sequence \"" + schema + "\".\"" + seqName+"\"" + - "no cycle \n"+ + " no cycle \n"+ "increment " + restoreSeq.getSequence().getOptions().get("increment")+"\n"+ "start " + restoreSeq.getSequence().getOptions().get("start_value")+"\n"+ "minvalue "+ restoreSeq.getSequence().getOptions().get("minimum_value")+"\n"+ "maxvalue " + restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; - query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to\""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; + query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to \""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; } st.execute(query); //TODO Восстановление привилегий diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index 296afe7..61bdb78 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -329,7 +329,7 @@ public String valuesToString(Collection datas, HashMap Date: Tue, 18 Aug 2020 13:54:40 +0300 Subject: [PATCH 05/68] fix table comment creation error --- .../ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 09f5d22..838f8b6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -101,7 +101,7 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception //restore comment if (restoreTable.getTable().getComment() != null && restoreTable.getTable().getComment().length() > 0){ st.execute(MessageFormat.format( - "COMMENT ON TABLE {0}.{1} IS '{2}'" + "COMMENT ON TABLE {0}.{1} IS ''{2}''" ,schema ,tblName ,restoreTable.getTable().getComment() From 292d2fad42baabde90085452b411aae2a250f7c7 Mon Sep 17 00:00:00 2001 From: dirak Date: Wed, 2 Sep 2020 09:11:04 +0300 Subject: [PATCH 06/68] partitioned tables PG --- .../dbgit/postgres/DBAdapterPostgres.java | 29 ++++++++++-- .../postgres/DBRestoreTablePostgres.java | 47 +++++++++++++++---- 2 files changed, 65 insertions(+), 11 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index d000d18..d9cf107 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -212,8 +212,16 @@ public Map getTables(String schema) { " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + " WHERE c.conrelid = to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid\n" + " and c1.relkind = 'r' AND c.contype = 'f'\n" + - " )\n" + - "from pg_tables \n" + + " ), \n" + + "(SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) oid, \n" + + " pg_get_partkeydef((SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema))) partkeydef, \n" + + " parent.relname parent, \n" + + " pg_get_expr(child.relpartbound, child.oid) \n" + + "from pg_tables \n" + + "left outer join pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) = pg_inherits.inhrelid \n" + + "left outer JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + + "left outer JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + + "where upper(schemaname) = upper(:schema)"; Connection connect = getConnection(); @@ -229,6 +237,10 @@ public Map getTables(String schema) { if(rs.getArray("dependencies") != null){ table.setDependencies(new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray()))); } else table.setDependencies(new HashSet<>()); + if (rs.getString("parent") != null) { + table.getDependencies().add(schema + "/" + rs.getString("parent") + ".tbl"); + } + rowToProperties(rs, table.getOptions()); listTable.put(nameTable, table); } @@ -255,8 +267,15 @@ public DBTable getTable(String schema, String name) { " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + " WHERE c.conrelid = to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid\n" + " and c1.relkind = 'r' AND c.contype = 'f'\n" + - " )" + + " ), \n" + + "(SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"')) oid, \n" + + " pg_get_partkeydef((SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"'))) partkeydef, \n" + + " parent.relname parent, \n" + + " pg_get_expr(child.relpartbound, child.oid) \n" + "from pg_tables \n" + + "left outer join pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"')) = pg_inherits.inhrelid \n" + + "left outer JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + + "left outer JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + "where upper(schemaname) = upper('"+schema+"') \n" + "and tablename = '"+name+"'\n"; try { @@ -277,6 +296,10 @@ public DBTable getTable(String schema, String name) { if(rs.getArray("dependencies") != null){ table.setDependencies(new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray()))); } else table.setDependencies(new HashSet<>()); + if (rs.getString("parent") != null) { + table.getDependencies().add(schema + "/" + rs.getString("parent") + ".tbl"); + } + rowToProperties(rs, table.getOptions()); } stmt.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 09f5d22..ce15a68 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -62,7 +62,7 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTable").withParams(schema+"."+tblName), 1); //find existing table and set tablespace or create - if(existingTable.loadFromDB()){ + if (existingTable.loadFromDB()){ StringProperties exTablespace = existingTable.getTable().getOptions().get("tablespace"); StringProperties restoreTablespace = restoreTable.getTable().getOptions().get("tablespace"); if( @@ -83,18 +83,38 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); } else { ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "createTable"), 2); + + Collection fields = restoreTable.getFields().values(); + StringBuilder columnsBld = new StringBuilder(); + + for (DBTableField field : fields) { + String fieldStr = field.getName() + " " + field.getTypeSQL().replace("NOT NULL" , ""); + columnsBld.append(fieldStr).append(", "); + } + String columns = columnsBld.substring(0, columnsBld.length() - 2); + String createTableDdl = MessageFormat.format( - "create table {0}.{1}() tablespace {2};\n alter table {0}.{1} owner to {3}" + "create table {0}.{1}({4}) {2};\n alter table {0}.{1} owner to {3}" ,schema ,tblName ,restoreTable.getTable().getOptions().getChildren().containsKey("tablespace") - ? restoreTable.getTable().getOptions().get("tablespace").getData() - : "pg_default" + ? "tablespace " + restoreTable.getTable().getOptions().get("tablespace").getData() + : "" ,restoreTable.getTable().getOptions().getChildren().containsKey("owner") ? restoreTable.getTable().getOptions().get("owner").getData() : "postgres" + , columns ); + + if (restoreTable.getTable().getOptions().getChildren().containsKey("partkeydef")) { + createTableDdl = createTableDdl.replace(" ) ", + ") PARTITION BY " + + restoreTable.getTable().getOptions().getChildren().get("partkeydef") + + " "); + } + st.execute(createTableDdl); + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); } @@ -123,12 +143,13 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception for(DBTableField tblField : values) { String fieldName = DBAdapterPostgres.escapeNameIfNeeded(tblField.getName()); +/* st.execute( "alter table "+ tblSam +" add column " + fieldName + " " + tblField.getTypeSQL().replace("NOT NULL", "") ); - +*/ if (tblField.getDescription() != null && tblField.getDescription().length() > 0) st.execute( "COMMENT ON COLUMN " + tblSam + "." @@ -152,7 +173,16 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception } ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); } - + + if (restoreTable.getTable().getOptions().getChildren().containsKey("parent")) { + String attachPart = " ALTER TABLE " + + schema + "." + restoreTable.getTable().getOptions().getChildren().get("parent") + + " ATTACH PARTITION " + + schema + "." + tblName + " " + + restoreTable.getTable().getOptions().getChildren().get("pg_get_expr"); + st.execute(attachPart); + } + if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 2); for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { @@ -301,7 +331,7 @@ public void restoreTableFieldsPostgres(IMetaObject obj) throws Exception } // set primary key for(DBConstraint tableconst: restoreTable.getConstraints().values()) { - if(tableconst.getConstraintType().equals("p")) { + if(tableconst.getConstraintType().equals("p") && !restoreTable.getTable().getOptions().getChildren().containsKey("parent")) { st.execute("alter table "+ tblName +" add constraint "+ DBAdapterPostgres.escapeNameIfNeeded(tableconst.getName()) + " "+tableconst.getSql().replace(" " + tableconst.getSql() + ".", " " + schema + ".")); break; } @@ -454,7 +484,8 @@ private void createConstraint(MetaTable restoreTable, DBConstraint constr, State .replace(" " + constr.getSchema() + ".", " " + schema + ".") .replace("REFERENCES ", "REFERENCES " + schema + ".") ); - st.execute(constrDdl); + if (!restoreTable.getTable().getOptions().getChildren().containsKey("parent")) + st.execute(constrDdl); } From 67d3d1efe41fb940116f14a5544445e7d865e22d Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 15:17:15 +0300 Subject: [PATCH 07/68] DBAdapter.java refactor CmdRestore.java refactor Moved backupDatabase into CmdRestore.execute DBBackupAdapter.java fix and refactor --- .../fusionsoft/dbgit/adapters/DBAdapter.java | 245 +++++++++--------- .../dbgit/adapters/DBBackupAdapter.java | 89 +++---- .../fusionsoft/dbgit/command/CmdRestore.java | 125 +++++---- src/main/resources/lang/eng.yaml | 3 + 4 files changed, 235 insertions(+), 227 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 8132d6a..2631944 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -3,6 +3,8 @@ import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.data_table.*; +import ru.fusionsoft.dbgit.dbobjects.DBOptionsObject; +import ru.fusionsoft.dbgit.dbobjects.DBRole; import ru.fusionsoft.dbgit.dbobjects.DBTableField; import ru.fusionsoft.dbgit.meta.*; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -15,6 +17,7 @@ import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; +import java.util.Set; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; @@ -35,7 +38,6 @@ public abstract class DBAdapter implements IDBAdapter { public void setConnection(Connection conn) { connect = conn; } - @Override public Connection getConnection() { try { @@ -83,155 +85,70 @@ public OutputStream getStreamOutputSqlCommand() { public Boolean isExecSql() { return isExec; } + @Override public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { Connection connect = getConnection(); DBGitLang lang = DBGitLang.getInstance(); - boolean toMakeBackup = DBGitConfig.getInstance().getBoolean("core", "TO_MAKE_BACKUP", true); try { - List tables = new ArrayList(); - List tablesData = new ArrayList(); - - List createdSchemas = new ArrayList(); - List createdRoles = new ArrayList(); - SortedListMetaObject restoreObjs = updateObjs.getSortedList(); - - if(toMakeBackup){ - IDBBackupAdapter ba = getBackupAdapterFactory().getBackupAdapter(this); - ba.backupDatabase(updateObjs); - } - - for (IMetaObject obj : restoreObjs.sortFromFree()) { - Integer step = 0; + List tables = new ArrayList<>(); + Set createdSchemas = getSchemes().values().stream().map(DBOptionsObject::getName).collect(Collectors.toSet()); + Set createdRoles = getRoles().values().stream().map(DBRole::getName).collect(Collectors.toSet()); - String schemaName = getSchemaName(obj); - if (schemaName != null) { - schemaName = (SchemaSynonym.getInstance().getSchema(schemaName) != null) - ? SchemaSynonym.getInstance().getSchema(schemaName) - : schemaName; - } - - boolean res = false; + for (IMetaObject obj : updateObjs.getSortedList().sortFromFree()) { Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); - DBGitIgnore ignore = DBGitIgnore.getInstance(); - if (step == 0) { - IDBConvertAdapter convertAdapter = getConvertAdapterFactory().getConvertAdapter(obj.getType().getValue()); + int step = 0; + boolean res = false; - boolean isContainsNative = false; - if (obj instanceof MetaTable) { - MetaTable table = (MetaTable) obj; - for (DBTableField field : table.getFields().values()) { if (field.getTypeUniversal().equals("native")) { isContainsNative = true; break; } } - } + IDBAdapterRestoreMetaData restoreAdapter = getFactoryRestore().getAdapterRestore(obj.getType(), this) ; + if(restoreAdapter == null) throw new Exception("restore adapter is null"); +// ConsoleWriter.printlnGreen(lang.getValue("general", "restore", "restoreType").withParams(obj.getType().toString().substring(5), obj.getName())); - if (isContainsNative) { - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "restore", "unsupportedTypes").withParams(obj.getName())); - continue; - } - if (convertAdapter != null) { - if (!createdSchemas.contains(schemaName) && schemaName != null) { - createSchemaIfNeed(schemaName); - createdSchemas.add(schemaName); - } + obj = tryConvert(obj); + createRoleIfNeed(obj, createdRoles); + createSchemaIfNeed(obj, createdSchemas); - String ownerName = getOwnerName(obj); - if (!ignore.matchOne("*." + DBGitMetaType.DBGitRole.getValue()) && !getRoles().containsKey(ownerName) && !createdRoles.contains(ownerName) && ownerName != null) { - createRoleIfNeed(ownerName); - createdRoles.add(ownerName); - } + while (!res) { + res = restoreAdapter.restoreMetaObject(obj, step++); - obj = convertAdapter.convert(getDbType(), getDbVersion(), obj); - } + if (step > 100) { throw new Exception(lang.getValue("errors", "restore", "restoreErrorDidNotReturnTrue").toString()); } + if (obj instanceof MetaTable){ tables.add((MetaTable) obj); } } - - while (!res) { - if (obj.getDbType() == null) { - ConsoleWriter.println(lang.getValue("errors", "emptyDbType")); - break; - } - - if (getFactoryRestore().getAdapterRestore(obj.getType(), this) == null || - !obj.getDbType().equals(getDbType())) - break; - - if (!createdSchemas.contains(schemaName) && schemaName != null) { - createSchemaIfNeed(schemaName); - createdSchemas.add(schemaName); - } - - String ownerName = getOwnerName(obj); - if (!ignore.matchOne("*." + DBGitMetaType.DBGitRole.getValue()) && !getRoles().containsKey(ownerName) && !createdRoles.contains(ownerName) && ownerName != null) { - createRoleIfNeed(ownerName); - createdRoles.add(ownerName); - } - - if (obj instanceof MetaTable) { - MetaTable table = (MetaTable) obj; - if (!tables.contains(table)) - tables.add(table); - } - - if (obj instanceof MetaTableData) { - MetaTableData tableData = (MetaTableData) obj; - if (!tables.contains(tableData)) - tablesData.add(tableData); - } - //call restoreAdapter.restoreMetaObject with the next 'step' until it returns true - res = getFactoryRestore().getAdapterRestore(obj.getType(), this).restoreMetaObject(obj, step); - step++; - - if (step > 100) { - throw new Exception(lang.getValue("errors", "restore", "restoreErrorDidNotReturnTrue").toString()); - } - } - Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); - Long diff = timestampAfter.getTime() - timestampBefore.getTime(); - ConsoleWriter.println("(" + diff + " " + lang.getValue("general", "add", "ms") +")"); + Long timeDiff = new Timestamp(System.currentTimeMillis()).getTime() - timestampBefore.getTime(); + ConsoleWriter.detailsPrintlnGreen(MessageFormat.format("({1} {2})", obj.getName(), timeDiff, lang.getValue("general", "add", "ms"))); } + // restore table constraints, which is step(-1) of restoreMetaObject(MetaTable) for (MetaTable table : tables) { getFactoryRestore().getAdapterRestore(DBGitMetaType.DBGitTable, this).restoreMetaObject(table, -1); } -/* - for (MetaTableData tableData : tablesData) { - getFactoryRestore().getAdapterRestore(DBGitMetaType.DbGitTableData, this).restoreMetaObject(tableData, -2); - } -*/ connect.commit(); } catch (Exception e) { //TODO wont work with ExceptionDBGit*, cause they call System.exit(1) in ctor; connect.rollback(); - ConsoleWriter.detailsPrintlnRed(e.getLocalizedMessage()); - e.printStackTrace(); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "restoreError").toString(), e); } finally { //connect.setAutoCommit(false); } } - + @Override public void deleteDataBase(IMapMetaObject deleteObjs) throws Exception { deleteDataBase(deleteObjs, false); } - public void deleteDataBase(IMapMetaObject deleteObjs, boolean isDeleteFromIndex) throws Exception { Connection connect = getConnection(); DBGitIndex index = DBGitIndex.getInctance(); try { - //start transaction - boolean toMakeBackup = DBGitConfig.getInstance().getBoolean("core", "TO_MAKE_BACKUP", true); - List deleteObjsSorted = deleteObjs.getSortedList().sortFromDependant(); - for (IMetaObject obj : deleteObjsSorted) { - if (toMakeBackup) { obj = getBackupAdapterFactory().getBackupAdapter(this).backupDBObject(obj); } getFactoryRestore().getAdapterRestore(obj.getType(), this).removeMetaObject(obj); if(isDeleteFromIndex) index.removeItem(obj); } - connect.commit(); } catch (Exception e) { connect.rollback(); @@ -240,27 +157,89 @@ public void deleteDataBase(IMapMetaObject deleteObjs, boolean isDeleteFromIndex) //connect.setAutoCommit(false); } } - - public String cleanString(String str) { - String dt = str.replace("\r\n", "\n"); - while (dt.contains(" \n")) dt = dt.replace(" \n", "\n"); - dt = dt.replace("\t", " ").trim(); - - return dt; - } - + public void rowToProperties(ResultSet rs, StringProperties properties) { try { for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) { - if (rs.getString(i) == null) continue ; - + if (rs.getString(i) == null) continue ; + properties.addChild(rs.getMetaData().getColumnName(i).toLowerCase(), cleanString(rs.getString(i))); } } catch(Exception e) { throw new ExceptionDBGitRunTime(e); } } - + public String cleanString(String str) { + String dt = str.replace("\r\n", "\n"); + while (dt.contains(" \n")) dt = dt.replace(" \n", "\n"); + dt = dt.replace("\t", " ").trim(); + + return dt; + } + + private IMetaObject tryConvert(IMetaObject obj) throws Exception { + if ( obj.getDbType() == null) throw new Exception(lang.getValue("errors", "emptyDbType").toString()); + + if ( isSameDbType(obj) && isSameDbVersion(obj)) return obj; + + if ( checkContainsNativeFields(obj)) { + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "restore", "unsupportedTypes").withParams(obj.getName())); + return obj; + } + + IDBConvertAdapter convertAdapter = getConvertAdapterFactory().getConvertAdapter(obj.getType().getValue()); + if (convertAdapter != null) return convertAdapter.convert(getDbType(), getDbVersion(), obj); + else { + throw new Exception(MessageFormat.format( + "Could not get convert adapter for {0} ({1} {2})", + obj.getName(), obj.getDbType().toString(), obj.getDbVersion() + )); + } + } + private void createSchemaIfNeed(IMetaObject obj, Set createdSchemas) throws Exception { + String schemaName = getSchemaSynonymName(obj); + if(schemaName == null){ + ConsoleWriter.detailsPrintlnRed(MessageFormat.format("Object {0} schema is null", obj.getName())); + return; + } + if (!createdSchemas.contains(schemaName)) { + createSchemaIfNeed(schemaName); + createdSchemas.add(schemaName); + } + } + private void createRoleIfNeed(IMetaObject obj, Set createdRoles) throws ExceptionDBGit { +// boolean isRolesUnignored = !DBGitIgnore.getInstance().matchOne("*." + DBGitMetaType.DBGitRole.getValue()); + String ownerName = getOwnerName(obj); + + if(ownerName != null){ + if ( !createdRoles.contains(ownerName)) { + createRoleIfNeed(ownerName); + createdRoles.add(ownerName); + } + } + + } + + private boolean checkContainsNativeFields(IMetaObject obj){ + if (obj instanceof MetaTable) { + MetaTable table = (MetaTable) obj; + for (DBTableField field : table.getFields().values()) { + if (field.getTypeUniversal().equals(FieldType.NATIVE)) { + return true; + } + } + } + return false; + } + private String getOwnerName(IMetaObject obj) { + if (obj instanceof MetaSql) + return ((MetaSql) obj).getSqlObject().getOwner(); + else if (obj instanceof MetaTable) + return ((MetaTable) obj).getTable().getOptions().get("owner").getData(); + else if (obj instanceof MetaSequence) + return ((MetaSequence) obj).getSequence().getOptions().get("owner").getData(); + else return null; + } private String getSchemaName(IMetaObject obj) { if (obj instanceof MetaSql) return ((MetaSql) obj).getSqlObject().getSchema(); @@ -268,17 +247,27 @@ else if (obj instanceof MetaTable) return ((MetaTable) obj).getTable().getSchema(); else if (obj instanceof MetaSequence) return ((MetaSequence) obj).getSequence().getSchema(); + else if (obj instanceof MetaTableData) + return ((MetaTableData) obj).getTable().getSchema(); else return null; } - - private String getOwnerName(IMetaObject obj) { - if (obj instanceof MetaSql) - return ((MetaSql) obj).getSqlObject().getOwner(); - else if (obj instanceof MetaTable) - return ((MetaTable) obj).getTable().getOptions().get("owner").getData(); - else if (obj instanceof MetaSequence) - return ((MetaSequence) obj).getSequence().getOptions().get("owner").getData(); - else return null; + private String getSchemaSynonymName(String schemaName) throws Exception { + String schemaSynonym = schemaName != null + ? SchemaSynonym.getInstance().getSchema(schemaName) + : null; + + return (schemaSynonym != null) + ? schemaSynonym + : schemaName; + } + private String getSchemaSynonymName(IMetaObject obj) throws Exception { + return getSchemaSynonymName(getSchemaName(obj)); + } + private boolean isSameDbType(IMetaObject obj){ + return obj.getDbType().equals(getDbType()); + } + private boolean isSameDbVersion(IMetaObject obj){ + return obj.getDbVersion().equals(getDbVersion()); } public void registryMappingTypes() { diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java index 0aa4d35..2d1de7d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java @@ -1,6 +1,6 @@ package ru.fusionsoft.dbgit.adapters; -import com.diogonunes.jcdp.color.api.Ansi; +import ru.fusionsoft.dbgit.core.DBGitIndex; import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.GitMetaDataManager; import ru.fusionsoft.dbgit.meta.*; @@ -20,6 +20,8 @@ public abstract class DBBackupAdapter implements IDBBackupAdapter { private boolean saveToSchema; protected DBGitLang lang = DBGitLang.getInstance(); + protected DBGitIndex dbGitIndex; + public void setAdapter(IDBAdapter adapter) { this.adapter = adapter; @@ -56,7 +58,7 @@ public boolean isExists(IMetaObject imo) { } } - public void backupDatabase(IMapMetaObject backupObjs) throws Exception { + public void backupDatabase(IMapMetaObject updateObjs) throws Exception { // Condition: we should not refer from backups on non-backup objects // -> we need to backup restoring objects dependencies @@ -65,92 +67,90 @@ public void backupDatabase(IMapMetaObject backupObjs) throws Exception { // -> we need to drop old backups of the objects + old backup dependencies // collect yet existing backups of restore objects - Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); +// Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); + dbGitIndex = DBGitIndex.getInctance(); + StatementLogging stLog = new StatementLogging(adapter.getConnection(), adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - IMapMetaObject dbObjs = GitMetaDataManager.getInstance().loadDBMetaData(true); + IMapMetaObject dbObjs = GitMetaDataManager.getInstance().loadDBMetaData(); - IMapMetaObject backupList = new TreeMapMetaObject(dbObjs.values().stream() - .filter( x-> backupObjs.containsKey(x.getName()) ) + IMapMetaObject dbToBackup = new TreeMapMetaObject(dbObjs.values().stream() + .filter( x-> updateObjs.containsKey(x.getName()) ) .collect(Collectors.toList())); - List nonBackupList = dbObjs.values().stream() - .filter(x -> !backupObjs.containsKey(x.getName())) + List dbNotToBackup = dbObjs.values().stream() + .filter(x -> !updateObjs.containsKey(x.getName())) .collect(Collectors.toList()); - IMapMetaObject existingBackups = new TreeMapMetaObject(dbObjs.values().stream() + IMapMetaObject dbAllBackups = new TreeMapMetaObject(dbObjs.values().stream() .filter(this::isBackupObject) .collect(Collectors.toList())); - ConsoleWriter.printlnColor(MessageFormat.format("Backing up {0} objects... {1} are in database:\n\t- {2}", - backupObjs.size(), backupList.size(), - String.join("\n\t- ", backupList.keySet()) - ), Ansi.FColor.MAGENTA, 1); + ConsoleWriter.printlnGreen(MessageFormat.format("Try to backup {0} present of {1} restoring objects ", dbToBackup.size(), updateObjs.size())); // collect restore objects dependencies to satisfy all backups create needs // so dependencies will be backed up too Map addedObjs; do{ - addedObjs = nonBackupList.stream().filter( nonBackup -> - nonBackup.getUnderlyingDbObject() != null - && backupList.values().stream().anyMatch( - backup -> backup.getUnderlyingDbObject().getDependencies().contains(nonBackup.getName()) + addedObjs = dbNotToBackup.stream().filter( notToBackup -> + notToBackup.getUnderlyingDbObject() != null && + dbToBackup.values().stream().anyMatch( + toBackup -> toBackup.dependsOn(notToBackup) ) ).collect(Collectors.toMap(IMetaObject::getName, Function.identity() )); - nonBackupList.removeAll(addedObjs.values()); - backupList.putAll(addedObjs); + dbNotToBackup.removeAll(addedObjs.values()); + dbToBackup.putAll(addedObjs); if(addedObjs.size() > 0) { - ConsoleWriter.printlnColor( - MessageFormat.format("- found {0} depending: {1}", addedObjs.size(), String.join(" ,", addedObjs.keySet())), - Ansi.FColor.MAGENTA, 2 + ConsoleWriter.detailsPrintlnGreen(MessageFormat.format("Found {0} depending backups: {1}" + , addedObjs.size(), String.join(" ,", addedObjs.keySet())) ); } } while (addedObjs.size() > 0); //so we have a full backup list, let's get a drop list + if(dbToBackup.size() > 0){ + Set suspectBackupNames = dbToBackup.values().stream().map( x->getBackupNameMeta(x).getMetaName()).collect(Collectors.toSet()); + List dropList = new ArrayList<>(); - if(backupList.size() > 0){ - - IMapMetaObject backupListExisting = new TreeMapMetaObject(existingBackups.values().stream() - .filter(x -> backupList.containsKey(x.getName())) + IMapMetaObject dbDroppingBackups = new TreeMapMetaObject(dbAllBackups.values().stream() + .filter(dbBackup -> suspectBackupNames.contains(dbBackup.getName())) .collect(Collectors.toList())); - List backupListExistingDependant = existingBackups.values().stream() - .filter( x -> - !backupListExisting.containsKey(x.getName()) - || x.getUnderlyingDbObject().getDependencies().contains(x.getName()) - ) - .collect(Collectors.toList()); + List dbDroppingBackupsDeps = dbAllBackups.values().stream() + .filter( dbBackup -> + !dbDroppingBackups.containsKey(dbBackup.getName()) + && dbDroppingBackups.values().stream().anyMatch(dbBackup::dependsOn) + ).collect(Collectors.toList()); - List dropList = new ArrayList<>(backupListExisting.values()); - dropList.addAll(backupListExistingDependant); + dropList.addAll(dbDroppingBackups.values()); + dropList.addAll(dbDroppingBackupsDeps); List dropListSorted = new SortedListMetaObject(dropList).sortFromDependant(); - ConsoleWriter.printlnColor("Rewriting "+dropList.size()+" backups (with dependencies)", Ansi.FColor.MAGENTA, 1); - dropListSorted.forEach( x -> ConsoleWriter.printlnColor( "- " + x.getName(), Ansi.FColor.MAGENTA, 1)); + ConsoleWriter.printlnGreen(MessageFormat.format("Rewriting {0} backups with {1} dependencies", dbDroppingBackups.size(), dbDroppingBackupsDeps.size())); + dropListSorted.forEach( x -> ConsoleWriter.detailsPrintlnGreen( x.getName())); //drop backups in one place for(IMetaObject imo : dropListSorted){ - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "droppingBackup").withParams(imo.getName()), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "droppingBackup").withParams(imo.getName()), 1); dropIfExists(imo, stLog); ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); } - Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); - ConsoleWriter.detailsPrintLn(MessageFormat.format("({0})", - lang.getValue("general", "add", "ms").withParams(String.valueOf(timestampAfter.getTime() - timestampBefore.getTime())) - )); - //create backups - for(IMetaObject imo : backupList.getSortedList().sortFromFree()){ + for(IMetaObject imo : dbToBackup.getSortedList().sortFromFree()){ backupDBObject(imo); } + + // Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); + // ConsoleWriter.detailsPrintLn(MessageFormat.format("({0})", + // lang.getValue("general", "add", "ms").withParams(String.valueOf(timestampAfter.getTime() - timestampBefore.getTime())) + // )); } } @@ -162,7 +162,8 @@ public NameMeta getBackupNameMeta(IMetaObject imo){ return new NameMeta(backupSchema, backupName, (DBGitMetaType) imo.getType()); } - public boolean isBackupObject(IMetaObject imo){ + public boolean isBackupObject(IMetaObject imo) { + if(dbGitIndex != null && dbGitIndex.getTreeItems().containsKey(imo.getName())) return false; NameMeta nm = new NameMeta(imo); return nm.getName().contains(PREFIX) || nm.getSchema().contains(PREFIX); } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java index 121ad2c..47c627e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java @@ -2,6 +2,7 @@ import java.io.File; import java.io.FileOutputStream; +import java.io.IOException; import java.nio.file.Files; import java.text.SimpleDateFormat; import java.util.Date; @@ -43,41 +44,33 @@ public Options getOptions() { @Override public void execute(CommandLine cmdLine) throws Exception { + IDBAdapter adapter = null; + File autoScriptFile = createScriptFile(); + FileOutputStream scriptOutputStream = new FileOutputStream(autoScriptFile); + GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); + + ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); + ConsoleWriter.println(""); + boolean toMakeChanges = cmdLine.hasOption("r"); + boolean toMakeBackup = DBGitConfig.getInstance().getBoolean("core", "TO_MAKE_BACKUP", true); try { - AdapterFactory.createAdapter(); + adapter = AdapterFactory.createAdapter(); + adapter.setDumpSqlCommand(scriptOutputStream, toMakeChanges); } catch (NullPointerException e) { ConsoleWriter.println(getLang().getValue("errors", "restore", "cantConnect")); System.exit(0); } - GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); + IMapMetaObject dbObjs = gmdm.loadDBMetaData(); IMapMetaObject fileObjs = gmdm.loadFileMetaData(); IMapMetaObject updateObjs = new TreeMapMetaObject(); IMapMetaObject deleteObjs = new TreeMapMetaObject(); - SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); - File scriptFile = new File(DBGitPath.getScriptsPath() + "script-" + format.format(new Date()) + ".sql"); - - //Console output - ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); - - boolean toMakeBackup = DBGitConfig.getInstance().getBoolean("core", "TO_MAKE_BACKUP", true); - if(toMakeBackup) ConsoleWriter.println(getLang().getValue("general", "restore", "willMakeBackup").toString()); - - if (cmdLine.hasOption("r")) { ConsoleWriter.println(getLang().getValue("general", "restore", "toMakeChanges").toString()); } - else { ConsoleWriter.println(getLang().getValue("general", "restore", "notMakeChanges").withParams(scriptFile.getAbsolutePath())); } - - //File output - FileOutputStream fop = null; - FileOutputStream scriptOutputStream = null; - - DBGitPath.createScriptsDir(); - if (!scriptFile.exists()) { scriptFile.createNewFile(); } - scriptOutputStream = new FileOutputStream(scriptFile); - - IDBAdapter adapter = AdapterFactory.createAdapter(); - adapter.setDumpSqlCommand(scriptOutputStream, cmdLine.hasOption("r")); + ConsoleWriter.println(""); + if (toMakeBackup) { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "willMakeBackup").toString()); } + if (toMakeChanges) { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "toMakeChanges").toString()); } + else { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "notMakeChanges").withParams(autoScriptFile.getAbsolutePath())); } //delete that not present in HEAD try { @@ -85,10 +78,10 @@ public void execute(CommandLine cmdLine) throws Exception { DBGitIgnore ignore = DBGitIgnore.getInstance(); ConsoleWriter.println(getLang().getValue("general", "restore", "seekingToRemove")); - for (ItemIndex item : Lists.newArrayList(index.getTreeItems().values())) { - if (ignore.matchOne(item.getName())) continue; - if (item.getIsDelete()) { - if( !dbObjs.containsKey(item.getName()) ) { + for ( ItemIndex item : index.getTreeItems().values() ) { + if ( ignore.matchOne(item.getName()) ) continue; + if ( item.getIsDelete() ) { + if ( !dbObjs.containsKey(item.getName()) ) { ConsoleWriter.println(getLang().getValue("general", "restore", "notExists").withParams(item.getName())); index.removeItem(item.getName()); } else { @@ -106,44 +99,43 @@ public void execute(CommandLine cmdLine) throws Exception { } } } - if (deleteObjs.size() == 0){ - ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRemove")); - } else { - if (cmdLine.hasOption("r")) ConsoleWriter.println(getLang().getValue("general", "restore", "removing")); - gmdm.deleteDataBase(deleteObjs, true); - } ConsoleWriter.println(getLang().getValue("general", "restore", "seekingToRestore")); for (IMetaObject obj : fileObjs.values()) { - Boolean isRestore = false; - try { - IMetaObject dbObj = IMetaObject.create(obj.getName()); - gmdm.loadFromDB(dbObj); - isRestore = !dbObj.getHash().equals(obj.getHash()); - } catch (ExceptionDBGit e) { - isRestore = true; - e.printStackTrace(); - } catch (ExceptionDBGitRunTime e) { - isRestore = true; - e.printStackTrace(); - } - if (isRestore) { - //запомнили файл если хеш разный или объекта нет - updateObjs.put(obj); - if (updateObjs.size() == 1) ConsoleWriter.println(getLang().getValue("general", "restore", "toRestore")); + //запомнили файл если хеш разный или объекта нет + if (checkNeedsRestore(obj)) { + updateObjs.put(obj); + if (updateObjs.size() == 1){ + ConsoleWriter.println(getLang().getValue("general", "restore", "toRestore")); + } ConsoleWriter.println(" " + obj.getName()); } } + if(toMakeBackup && toMakeChanges) { + IMapMetaObject backupObjs = new TreeMapMetaObject(); + backupObjs.putAll(deleteObjs); + backupObjs.putAll(updateObjs); + adapter.getBackupAdapterFactory().getBackupAdapter(adapter).backupDatabase(backupObjs); + } + + if (deleteObjs.size() == 0){ + ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRemove")); + } else { + if (toMakeChanges) ConsoleWriter.println(getLang().getValue("general", "restore", "removing")); + gmdm.deleteDataBase(deleteObjs, true); + } + if (updateObjs.size() == 0){ ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRestore")); } - if (cmdLine.hasOption("r")) { + if (toMakeChanges) { ConsoleWriter.println(getLang().getValue("general", "restore", "restoring")); } gmdm.restoreDataBase(updateObjs); + } finally { if (scriptOutputStream != null) { scriptOutputStream.flush(); @@ -151,17 +143,40 @@ public void execute(CommandLine cmdLine) throws Exception { } if (cmdLine.hasOption("s")) { String scriptName = cmdLine.getOptionValue("s"); - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "restore", "scriptWillSaveTo").withParams(scriptName)); - File file = new File(scriptName); + if (!file.exists()) { - Files.copy(scriptFile.toPath(), file.toPath()); - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "restore", "created").withParams(scriptName)); + ConsoleWriter.detailsPrintLn(getLang().getValue("general", "restore", "scriptWillSaveTo").withParams(scriptName)); + Files.copy(autoScriptFile.toPath(), file.toPath()); + } else { + ConsoleWriter.detailsPrintLn(getLang().getValue("errors", "restore", "fileAlreadyExists").withParams(scriptName)); } } } ConsoleWriter.println(getLang().getValue("general", "done")); } + private boolean checkNeedsRestore(IMetaObject obj){ + boolean isRestore = false; + try { + IMetaObject dbObj = IMetaObject.create(obj.getName()); + GitMetaDataManager.getInstance().loadFromDB(dbObj); + isRestore = !dbObj.getHash().equals(obj.getHash()); + } catch (ExceptionDBGit e) { + isRestore = true; + e.printStackTrace(); + } catch (ExceptionDBGitRunTime e) { + isRestore = true; + e.printStackTrace(); + } + return isRestore; + } + private File createScriptFile() throws ExceptionDBGit, IOException { + DBGitPath.createScriptsDir(); + SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); + File scriptFile = new File(DBGitPath.getScriptsPath() + "script-" + format.format(new Date()) + ".sql"); + if (!scriptFile.exists()) { scriptFile.createNewFile(); } + return scriptFile; + } } diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index 200b173..9cb282d 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -56,6 +56,7 @@ general: removing: Removing... removingObject: Removing {0}... created: Created file {0} + restoreType: Restoring {0} {1} ... restoreView: Restoring view {0} ... restoreTrigger: Restoring trigger {0} ... restoreSeq: Restoring sequence {0} ... @@ -66,6 +67,7 @@ general: restoreUser: Restoring user {0} ... restoreFnc: Restoring function {0} ... restoreTable: Restoring table {0} ... + restoreTableConstraints: Restoring table {0} constraints ... restoreTableData: Restoring table data for {0} ... restoreTablespace: Restoring tablespace {0} ... restoreConstr: Restoring constraints for table {0} ... @@ -154,6 +156,7 @@ errors: pkNotFound: PK not found for table {0}, cannot process row! cantConnect: Can't connect to db! errorLoadDelete: Error load and delete object + fileAlreadyExists: Error write script, file {0} already exists add: badCommand: Bad command. Not found object to add! cantFindObjectInDb: Can't find object {0} in database From 299efeda0a1f473fdcc60479105f604fc7194879 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 15:35:30 +0300 Subject: [PATCH 08/68] CmdCheckout, DBGit.java fix - now you can really checkout any commit CmdLink, CmdCheckout added -ls option to see current database url and branch\commit --- .../fusionsoft/dbgit/command/CmdCheckout.java | 25 ++++++++++++++++--- .../ru/fusionsoft/dbgit/command/CmdLink.java | 13 +++++++--- .../fusionsoft/dbgit/command/CmdStatus.java | 9 ++----- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 14 +++++------ 4 files changed, 39 insertions(+), 22 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java index b6538d1..de9aa88 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java @@ -5,10 +5,13 @@ import org.apache.commons.cli.Option; import org.apache.commons.cli.Options; +import org.eclipse.jgit.lib.Ref; +import org.eclipse.jgit.lib.Repository; +import org.eclipse.jgit.revwalk.RevWalk; import ru.fusionsoft.dbgit.core.DBGit; -import ru.fusionsoft.dbgit.core.DBGitIndex; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import java.text.MessageFormat; public class CmdCheckout implements IDBGitCommand { @@ -20,6 +23,7 @@ public CmdCheckout() { opts.addOption("u", false, getLang().getValue("help", "checkout-u").toString()); opts.addOption("nodb", false, getLang().getValue("help", "checkout-no-db").toString()); opts.addOption("upgrade", false, getLang().getValue("help", "checkout-u").toString()); + opts.addOption("ls", false, getLang().getValue("help", "checkout-ls").toString()); } @Override @@ -46,11 +50,24 @@ public Options getOptions() { public void execute(CommandLine cmdLine) throws Exception { String[] args = cmdLine.getArgs(); - ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); - + ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); + + Repository repo = DBGit.getInstance().getRepository(); + Ref head = repo.getAllRefs().get("HEAD"); + + if (cmdLine.hasOption("ls")){ + try(RevWalk walk = new RevWalk(repo)){ + ConsoleWriter.printlnGreen(MessageFormat.format( + "{0}: {1} ({2}) - {3}", + repo.getBranch(), head.getObjectId().getName(), head.getName(), + walk.parseCommit(head.getObjectId()).getShortMessage() + )); + } + return; + } + if (!cmdLine.hasOption("u") && !cmdLine.hasOption("nodb")) checkVersion(); - if (args == null || args.length == 0) { throw new ExceptionDBGit(getLang().getValue("errors", "checkout", "badCommand")); } else if (args.length == 1) { diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java index 02b7900..4dcb2da 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java @@ -21,6 +21,7 @@ public class CmdLink implements IDBGitCommand { public CmdLink() { opts.addOption("d", false, getLang().getValue("help", "link-d").toString()); + opts.addOption("ls", false, getLang().getValue("help", "link-ls").toString()); } public String getCommandName() { @@ -43,16 +44,20 @@ public Options getOptions() { @Override public void execute(CommandLine cmdLine) throws Exception { + DBConnection conn = DBConnection.getInstance(false); + if(cmdLine.hasOption("ls")) { + ConsoleWriter.printlnGreen(DBConnection.loadFileDBLink(new Properties())); + return; + } + + String[] args = cmdLine.getArgs(); - if(args == null || args.length == 0) { throw new ExceptionDBGit(getLang().getValue("errors", "link", "emptyLink")); } - + String url = args[0]; Properties props = CreateProperties(Arrays.copyOfRange(args, 1, args.length)); - - DBConnection conn = DBConnection.getInstance(false); if(conn.testingConnection(url, props)) { DBConnection.createFileDBLink(url, props, cmdLine.hasOption("d")); diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdStatus.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdStatus.java index b3648e0..daebca4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdStatus.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdStatus.java @@ -7,14 +7,9 @@ import com.diogonunes.jcdp.color.api.Ansi.FColor; -import ru.fusionsoft.dbgit.core.DBGit; -import ru.fusionsoft.dbgit.core.DBGitIndex; -import ru.fusionsoft.dbgit.core.DBGitPath; -import ru.fusionsoft.dbgit.core.GitMetaDataManager; -import ru.fusionsoft.dbgit.core.SchemaSynonym; +import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.meta.IMapMetaObject; import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaTableData; import ru.fusionsoft.dbgit.meta.TreeMapMetaObject; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -58,7 +53,7 @@ public void execute(CommandLine cmdLine) throws Exception { String repoVersion = DBGitIndex.getInctance().getRepoVersion(); ConsoleWriter.println(getLang().getValue("general", "status", "repVersion").withParams(repoVersion)); ConsoleWriter.println(getLang().getValue("general", "status", "dbgitVersion").withParams(DBGitIndex.VERSION)); - + if (!DBGitIndex.getInctance().isCorrectVersion()) ConsoleWriter.println(getLang().getValue("general", "status", "differentVersions")); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index 26979fc..1f0550b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -246,18 +246,18 @@ public void gitCheckout(String branch, String commit, boolean isNewBranch) throw CheckoutCommand checkout = git.checkout().setCreateBranch(isNewBranch).setName(branch); - if (commit != null) - checkout = checkout.setStartPoint(commit); - else { + if (commit != null){ + checkout = checkout.setName(commit); + } else { if (git.branchList().setListMode(ListMode.REMOTE).call().stream() - .filter(ref -> ref.getName().equals("refs/remotes/origin/" + branch)) - .count() > 0) - checkout = checkout.setStartPoint("remotes/origin/" + branch); + .filter(ref -> ref.getName().equals("refs/remotes/origin/" + branch)) + .count() > 0 + )checkout = checkout.setStartPoint("remotes/origin/" + branch); } result = checkout.call(); - ConsoleWriter.printlnGreen(result.getName()); + ConsoleWriter.printlnGreen(result != null ? result.getName() : commit); } else { MaskFilter maskAdd = new MaskFilter(branch); From 8c800a58dd8316ff4de7448e0ab5c2c62487e834 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 20:22:06 +0300 Subject: [PATCH 09/68] + IMetaObject.dependsOn method --- src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java index eb9cc3f..761a8cb 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java @@ -157,6 +157,11 @@ default DBSchemaObject getUnderlyingDbObject(){ return null; } + default boolean dependsOn(IMetaObject obj){ + if (this.getUnderlyingDbObject() == null || this.getUnderlyingDbObject().getDependencies() == null) return false; + return this.getUnderlyingDbObject().getDependencies().contains(obj.getName()); + } + static IMetaObject create(String name) throws ExceptionDBGit { NameMeta nm = new NameMeta(name); if (nm.getType() == null) throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "meta", "parseError").withParams(name)); From 7cf9dca87ea59996edd138c3e830780e7f81b17f Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 20:27:50 +0300 Subject: [PATCH 10/68] SortedListMetaObject fix error with IMetaObject self dependency, refactor --- .../dbgit/meta/SortedListMetaObject.java | 157 ++++++++---------- .../dbgit/meta/TreeMapMetaObject.java | 2 +- 2 files changed, 70 insertions(+), 89 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java index de3c517..9879eb0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java @@ -8,7 +8,7 @@ import ru.fusionsoft.dbgit.dbobjects.DBTable; import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import java.sql.Timestamp; + import java.util.*; import java.util.stream.Collectors; @@ -29,13 +29,13 @@ public SortedListMetaObject(Collection fromCollection){ } private void calculateImoCrossDependencies(){ - Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); +// Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); for(DBGitMetaType metaType : Sets.newHashSet(DBGitMetaType.DBGitTable, DBGitMetaType.DbGitFunction)){ List objectsOfType = collection.stream().filter(x->x.getType().equals(metaType) ).collect(Collectors.toList()); Map realNamesToMetaNames = objectsOfType.stream().collect(Collectors.toMap( - x->x.getUnderlyingDbObject().getSchema() + "." + x.getUnderlyingDbObject().getName(), + x-> x.getUnderlyingDbObject().getSchema() + "." + x.getUnderlyingDbObject().getName(), IMetaObject::getName ) ); @@ -44,7 +44,7 @@ private void calculateImoCrossDependencies(){ if(imo.getType().equals(DBGitMetaType.DbGitFunction)){ DBSQLObject dbsql = (DBSQLObject) imo.getUnderlyingDbObject(); Set deps = realNamesToMetaNames.keySet().stream() - .filter( x -> dbsql.getSql().contains(x) && !(dbsql.getSchema()+"."+dbsql.getName()).equals(x) ) + .filter( x -> dbsql.getSql().contains(x) /*&& !(dbsql.getSchema()+"."+dbsql.getName()).equals(x)*/ ) .map(realNamesToMetaNames::get) .collect(Collectors.toSet()); dbsql.setDependencies(deps); @@ -52,7 +52,7 @@ private void calculateImoCrossDependencies(){ if(imo.getType().equals(DBGitMetaType.DBGitTable)){ DBTable dbTable = (DBTable) imo.getUnderlyingDbObject(); Set deps = realNamesToMetaNames.values().stream() - .filter( x -> dbTable.getDependencies().contains(x) && !x.equals(imo.getName()) ) + .filter( x -> dbTable.getDependencies().contains(x) /*&& !x.equals(imo.getName())*/ ) .collect(Collectors.toSet()); dbTable.setDependencies(deps); } @@ -60,103 +60,84 @@ private void calculateImoCrossDependencies(){ } - Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); - Long diff = timestampAfter.getTime() - timestampBefore.getTime(); - ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "time").withParams(diff.toString())); - }; - - public List sortFromDependant() throws ExceptionDBGit { - if (listFromDependant == null) { - listFromDependant = new ArrayList<>(); - List types = Arrays - .stream(DBGitMetaType.values()) - .sorted(Comparator.comparing(DBGitMetaType::getPriority).reversed()) - .collect(Collectors.toList()); - - for (DBGitMetaType tp : types) { - - List objectsOfType = collection.stream().filter(x -> x.getType().equals(tp)).collect(Collectors.toList()); - if (!objectsOfType.isEmpty()) { - if (tp.equals(DBGitMetaType.DBGitTable) || (objectsOfType.get(0) instanceof MetaSql)) { +// Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); +// long diff = timestampAfter.getTime() - timestampBefore.getTime(); +// ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "time").withParams(Long.toString(diff))); + } - Set namesAllOfType = objectsOfType.stream().map(IMetaObject::getName).collect(Collectors.toSet()); - List objectsL0 = objectsOfType.stream() - .filter(x -> x.getUnderlyingDbObject().getDependencies().size() == 0) + public List createSortedList(boolean isSortedFromFree) throws ExceptionDBGit { + List list = new ArrayList<>(); + Comparator typeComparator = isSortedFromFree + ? Comparator.comparing(DBGitMetaType::getPriority) + : Comparator.comparing(DBGitMetaType::getPriority).reversed(); + Comparator imoComparator = isSortedFromFree + ? imoDependenceComparator + : imoDependenceComparator.reversed(); + + List types = Arrays + .stream(DBGitMetaType.values()) + .sorted(typeComparator) + .collect(Collectors.toList()); + + for (DBGitMetaType tp : types) { + List objectsOfType = collection.stream().filter(x -> x.getType().equals(tp)).collect(Collectors.toList()); + if (!objectsOfType.isEmpty()) { + if (tp.equals(DBGitMetaType.DBGitTable) || objectsOfType.get(0) instanceof MetaSql) { + Set namesAllOfType = objectsOfType.stream().map(IMetaObject::getName).collect(Collectors.toSet()); + List objectsL0 = objectsOfType.stream() + .filter(x -> { + Set deps = x.getUnderlyingDbObject().getDependencies(); + return deps.size() == 0 || ( deps.size() == 1 && deps.contains(x.getName()) ); + }) + .collect(Collectors.toList()); + + objectsOfType.removeAll(objectsL0); + while (!objectsOfType.isEmpty()) { + Set namesL0 = objectsL0.stream().map(IMetaObject::getName).collect(Collectors.toSet()); + List objectsL1 = objectsOfType + .stream() + .filter(x -> { + Set actualDeps = new HashSet<>(x.getUnderlyingDbObject().getDependencies()); + actualDeps.retainAll(namesAllOfType); + actualDeps.remove(x.getName()); + return namesL0.containsAll(actualDeps); + }) + .sorted(imoComparator) .collect(Collectors.toList()); - - objectsOfType.removeAll(objectsL0); - while (!objectsOfType.isEmpty()) { - Set namesL0 = objectsL0.stream().map(IMetaObject::getName).collect(Collectors.toSet()); - List objectsL1 = objectsOfType - .stream() - .filter(x -> { - Set actualDeps = new HashSet<>(x.getUnderlyingDbObject().getDependencies()); - actualDeps.retainAll(namesAllOfType); - return namesL0.containsAll(actualDeps); - }) - .sorted(imoDependenceComparator.reversed()) - .collect(Collectors.toList()); - if (objectsL1.isEmpty()) { - warnNotAdded(objectsOfType); - throw new ExceptionDBGit("infinite loop"); - } - objectsOfType.removeAll(objectsL1); - objectsL0.addAll(0, objectsL1); + if (objectsL1.isEmpty()) { + warnNotAdded(objectsOfType); + throw new ExceptionDBGit("infinite loop"); } - listFromDependant.addAll(objectsL0); - } else { - listFromDependant.addAll(objectsOfType); + objectsOfType.removeAll(objectsL1); + if(isSortedFromFree) { objectsL0.addAll(objectsL1); } else { objectsL0.addAll(0, objectsL1); } } + list.addAll(objectsL0); + } else { + list.addAll(objectsOfType); } } } +// int i = 0; +// for(IMetaObject imo : list){ +// ConsoleWriter.printlnRed(MessageFormat.format("{0}. {1}", i++, imo.getName())); +// } + return list; + } + + public List sortFromDependant() throws ExceptionDBGit { + if (listFromDependant == null) { + listFromDependant = createSortedList(false); + } return listFromDependant; - }; + } public List sortFromFree() throws ExceptionDBGit { if (listFromFree == null) { - listFromFree = new ArrayList<>(); - List types = Arrays.stream(DBGitMetaType.values()) - .sorted(Comparator.comparing(DBGitMetaType::getPriority)) - .collect(Collectors.toList()); - - for (DBGitMetaType tp : types) { - List objectsOfType = collection.stream().filter(x -> x.getType().equals(tp)).collect(Collectors.toList()); - if (!objectsOfType.isEmpty()) { - if (tp.equals(DBGitMetaType.DBGitTable) || objectsOfType.get(0) instanceof MetaSql) { - Set namesAllOfType = objectsOfType.stream().map(IMetaObject::getName).collect(Collectors.toSet()); - List objectsL0 = objectsOfType.stream().filter(x -> x.getUnderlyingDbObject().getDependencies().size() == 0).collect(Collectors.toList()); - - objectsOfType.removeAll(objectsL0); - while (!objectsOfType.isEmpty()) { - Set namesL0 = objectsL0.stream().map(IMetaObject::getName).collect(Collectors.toSet()); - List objectsL1 = objectsOfType - .stream() - .filter(x -> { - Set actualDeps = new HashSet<>(x.getUnderlyingDbObject().getDependencies()); - actualDeps.retainAll(namesAllOfType); - return namesL0.containsAll(actualDeps); - }) - .sorted(imoDependenceComparator) - .collect(Collectors.toList()); - if (objectsL1.isEmpty()) { - warnNotAdded(objectsOfType); - throw new ExceptionDBGit("infinite loop"); - } - objectsOfType.removeAll(objectsL1); - objectsL0.addAll(objectsL1); - } - listFromFree.addAll(objectsL0); - } else { - listFromFree.addAll(objectsOfType); - } - } - - } + listFromFree = createSortedList(true); } return listFromFree; - }; + } public static Comparator imoTypeComparator = Comparator.comparing(x->x.getType().getPriority()); public static Comparator imoDependenceComparator = (o1, o2) -> { diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/TreeMapMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/TreeMapMetaObject.java index f417e35..d167b3d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/TreeMapMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/TreeMapMetaObject.java @@ -36,7 +36,7 @@ public int compare(String nm1, String nm2) { } - public TreeMapMetaObject(List from){ + public TreeMapMetaObject(Collection from){ this(); this.putAll(from.stream().collect(Collectors.toMap(IMetaObject::getName, key->key))); } From 73304632b0378fa667894ed63f1f7fe3e0563dfc Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 20:32:20 +0300 Subject: [PATCH 11/68] MetaTable comparison fix --- .../ru/fusionsoft/dbgit/meta/MetaTable.java | 27 ++++++++++--------- .../ru/fusionsoft/dbgit/utils/CalcHash.java | 9 ++++++- 2 files changed, 23 insertions(+), 13 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java index 755c203..bcff345 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java @@ -126,7 +126,13 @@ public boolean loadFromDB(DBTable tbl) throws ExceptionDBGit { @Override public String getHash() { - CalcHash ch = new CalcHash(); + CalcHash ch = new CalcHash()/*{ + @Override + public CalcHash addData(String str){ + ConsoleWriter.detailsPrintlnGreen(str); + return super.addData(str); + } + }*/; ch.addData(this.getName()); if (getTable() != null) { @@ -142,20 +148,17 @@ public String getHash() { } - if (indexes != null) { - for (String item : indexes.keySet()) { - ch.addData(item); - ch.addData(indexes.get(item).getHash()); + for (String item : indexes.keySet()) { + if(constraints.containsKey(item)) continue; + ch.addData(item); + ch.addData(indexes.get(item).getHash()); - } } - - if (constraints != null) { - for (String item : constraints.keySet()) { - ch.addData(item); - ch.addData(constraints.get(item).getHash()); - } + for (String item : constraints.keySet()) { + ch.addData(item); + ch.addData(constraints.get(item).getHash()); + } return ch.calcHashStr(); diff --git a/src/main/java/ru/fusionsoft/dbgit/utils/CalcHash.java b/src/main/java/ru/fusionsoft/dbgit/utils/CalcHash.java index 5b2b499..3f65270 100644 --- a/src/main/java/ru/fusionsoft/dbgit/utils/CalcHash.java +++ b/src/main/java/ru/fusionsoft/dbgit/utils/CalcHash.java @@ -56,7 +56,14 @@ public CalcHash addDataFile(String filename) throws Exception { stream.close(); return this; } - + + public CalcHash addData(boolean data){ + return addData(String.valueOf(data)); + } + + public CalcHash addData(int data){ + return addData(String.valueOf(data)); + } public CalcHash addData(String data) { try { From 2d34a1dbc1f635cfbb3e5dbbb720a04e0b8d7d7b Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 21:04:29 +0300 Subject: [PATCH 12/68] Restore Sequence change owner error fix for Postgres Restore Table owner and tablespace fix --- .../dbgit/dbobjects/DBSequence.java | 11 +- .../dbgit/postgres/DBAdapterPostgres.java | 45 +-- .../postgres/DBRestoreSequencePostgres.java | 278 +++++++++--------- .../postgres/DBRestoreTablePostgres.java | 30 +- 4 files changed, 192 insertions(+), 172 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java index 93aa73a..77f991e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java @@ -22,6 +22,13 @@ public void setValue(Long value) { public StringProperties getOptions() { return options; } + + private StringProperties getOptionsFiltered() { + StringProperties props = new StringProperties(getOptions().getData()); + props.setChildren(getOptions().getChildren()); + props.deleteChild("blocking_table"); + return props; + } public void setOptions(StringProperties options) { this.options = options; @@ -29,11 +36,11 @@ public void setOptions(StringProperties options) { @Override public String getHash() { - + CalcHash ch = new CalcHash(); ch.addData(getSchema()); ch.addData(getName()); - ch.addData(getOptions().toString()); + ch.addData(getOptionsFiltered().toString()); ch.addData(getValue().toString()); return ch.calcHashStr(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index 331d257..a79d12b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -6,14 +6,12 @@ import java.util.*; import java.util.concurrent.TimeUnit; -import ru.fusionsoft.dbgit.adapters.AdapterFactory; import ru.fusionsoft.dbgit.adapters.DBAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBAdapterRestoteMetaData; import ru.fusionsoft.dbgit.adapters.IFactoryDBBackupAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitObjectNotFound; import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.core.db.FieldType; @@ -28,13 +26,11 @@ import ru.fusionsoft.dbgit.dbobjects.DBTable; import ru.fusionsoft.dbgit.dbobjects.DBTableData; import ru.fusionsoft.dbgit.dbobjects.DBTableField; -import ru.fusionsoft.dbgit.dbobjects.DBTableRow; import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; import ru.fusionsoft.dbgit.dbobjects.DBTrigger; import ru.fusionsoft.dbgit.dbobjects.DBUser; import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMapMetaObject; -import ru.fusionsoft.dbgit.meta.IMetaObject; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; @@ -125,18 +121,20 @@ public Map getTableSpaces() { @Override public Map getSequences(String schema) { - Map listSequence = new HashMap(); + Map listSequence = new HashMap<>(); try { Connection connect = getConnection(); String query = - "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option " + - "from pg_class cls " + - " join pg_roles rol on rol.oid = cls.relowner " + - " join pg_namespace nsp on nsp.oid = cls.relnamespace " + - " join information_schema.sequences s on cls.relname = s.sequence_name " + - "where nsp.nspname not in ('information_schema', 'pg_catalog') " + - " and nsp.nspname not like 'pg_toast%' " + - " and cls.relkind = 'S' and s.sequence_schema = :schema "; + "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option, cl.relname as blocking_table \n" + + "from pg_class cls \n" + + " join pg_roles rol on rol.oid = cls.relowner \n" + + " join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + + " join information_schema.sequences s on cls.relname = s.sequence_name \n" + + " left join pg_depend d on d.objid=cls.oid and d.classid='pg_class'::regclass and d.refclassid='pg_class'::regclass\n" + + " left join pg_class cl on cl.oid = d.refobjid and d.deptype='a' \n" + + "where nsp.nspname not in ('information_schema', 'pg_catalog')\n" + + " and nsp.nspname not like 'pg_toast%' \n" + + " and cls.relkind = 'S' and s.sequence_schema = :schema"; NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); stmt.setString("schema", schema); @@ -163,15 +161,17 @@ public Map getSequences(String schema) { public DBSequence getSequence(String schema, String name) { try { Connection connect = getConnection(); - String query = - "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option " + - "from pg_class cls " + - " join pg_roles rol on rol.oid = cls.relowner " + - " join pg_namespace nsp on nsp.oid = cls.relnamespace " + - " join information_schema.sequences s on cls.relname = s.sequence_name " + - "where nsp.nspname not in ('information_schema', 'pg_catalog') " + - " and nsp.nspname not like 'pg_toast%' " + - " and cls.relkind = 'S' and s.sequence_schema = :schema and s.sequence_name = :name "; + String query = + "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option, cl.relname as blocking_table \n" + + "from pg_class cls \n" + + " join pg_roles rol on rol.oid = cls.relowner \n" + + " join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + + " join information_schema.sequences s on cls.relname = s.sequence_name \n" + + " left join pg_depend d on d.objid=cls.oid and d.classid='pg_class'::regclass and d.refclassid='pg_class'::regclass\n" + + " left join pg_class cl on cl.oid = d.refobjid and d.deptype='a' \n" + + "where nsp.nspname not in ('information_schema', 'pg_catalog') \n" + + " and nsp.nspname not like 'pg_toast%' \n" + + " and cls.relkind = 'S' and s.sequence_schema = :schema and s.sequence_name = :name "; NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); stmt.setString("schema", schema); @@ -335,6 +335,7 @@ public Map getTableFields(String schema, String nameTable field.setTypeSQL(typeSQL); field.setIsNullable( !typeSQL.toLowerCase().contains("not null")); field.setTypeUniversal(FieldType.fromString(rs.getString("tp"))); + //TODO more verbose type override if(field.getTypeUniversal() == FieldType.TEXT) field.setTypeUniversal(FieldType.STRING); field.setFixed(false); field.setLength(rs.getInt("character_maximum_length")); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java index 7880d2c..5694b21 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java @@ -1,137 +1,141 @@ -package ru.fusionsoft.dbgit.postgres; - -import java.sql.Connection; -import java.util.Map; - -import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.dbobjects.DBFunction; -import ru.fusionsoft.dbgit.dbobjects.DBSequence; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaFunction; -import ru.fusionsoft.dbgit.meta.MetaSequence; -import ru.fusionsoft.dbgit.statement.StatementLogging; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -public class DBRestoreSequencePostgres extends DBRestoreAdapter { - - @Override - public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSeq").withParams(obj.getName()), 1); - try { - if (obj instanceof MetaSequence) { - MetaSequence restoreSeq = (MetaSequence)obj; - Map seqs = adapter.getSequences(((MetaSequence) obj).getSequence().getSchema()); - boolean exist = false; - if(!(seqs.isEmpty() || seqs == null)) { - for(DBSequence seq:seqs.values()) { - if(restoreSeq.getSequence().getName().equals(seq.getName())){ - String query=""; - exist = true; - String sequence = restoreSeq.getSequence().getSchema()+ "." +restoreSeq.getSequence().getName(); - if(!restoreSeq.getSequence().getOptions().get("cycle_option").equals(seq.getOptions().get("cycle_option"))) { - if(restoreSeq.getSequence().getOptions().get("cycle_option").equals("YES")) { - query+="alter sequence "+sequence + " cycle;\n"; - } - else { - query+="alter sequence "+sequence + " no cycle;\n"; - } - } - - if(!restoreSeq.getSequence().getOptions().get("increment").equals(seq.getOptions().get("increment"))) { - query+="alter sequence "+sequence+ " increment "+restoreSeq.getSequence().getOptions().get("increment")+";\n"; - } - - if(!restoreSeq.getSequence().getOptions().get("start_value").equals(seq.getOptions().get("start_value"))) { - query+="alter sequence "+sequence+" start "+restoreSeq.getSequence().getOptions().get("start_value")+";\n"; - } - - if(!restoreSeq.getSequence().getOptions().get("minimum_value").equals(seq.getOptions().get("minimum_value"))) { - query+="alter sequence "+sequence+ " minvalue "+restoreSeq.getSequence().getOptions().get("minimum_value")+";\n"; - } - - if(!restoreSeq.getSequence().getOptions().get("maximum_value").equals(seq.getOptions().get("maximum_value"))) { - query+="alter sequence "+sequence + " maxvalue "+restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; - } - - if(!restoreSeq.getSequence().getOptions().get("owner").equals(seq.getOptions().get("owner"))) { - query+="alter sequence "+sequence+" owner to "+restoreSeq.getSequence().getOptions().get("owner")+";\n"; - } - if(query.length()>1) { - st.execute(query); - } - //TODO Восстановление привилегий - } - } - } - if(!exist){ - String query=""; - String seqName = restoreSeq.getSequence().getName(); - String schema = restoreSeq.getSequence().getSchema(); - if(restoreSeq.getSequence().getOptions().get("cycle_option").equals("YES")){ - query+="create sequence \"" + schema + "\".\"" + seqName+"\"" + - "cycle \n"+ - "increment" + restoreSeq.getSequence().getOptions().get("increment")+"\n"+ - "start " + restoreSeq.getSequence().getOptions().get("start_value")+"\n"+ - "minvalue "+ restoreSeq.getSequence().getOptions().get("minimum_value")+"\n"+ - "maxvalue " + restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; - query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to\""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; - } - else { - query+="create sequence \"" + schema + "\".\"" + seqName+"\"" + - " no cycle \n"+ - "increment " + restoreSeq.getSequence().getOptions().get("increment")+"\n"+ - "start " + restoreSeq.getSequence().getOptions().get("start_value")+"\n"+ - "minvalue "+ restoreSeq.getSequence().getOptions().get("minimum_value")+"\n"+ - "maxvalue " + restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; - query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to \""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; - } - st.execute(query); - //TODO Восстановление привилегий - } - } - else - { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - st.close(); - } - return true; - } - - @Override - public void removeMetaObject(IMetaObject obj) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - - try { - if(! (obj instanceof MetaSequence)) throw new ExceptionDBGit("Wrong IMetaObject type, expected: seq, was: " + obj.getType().getValue()); - MetaSequence seqMeta = (MetaSequence) obj; - DBSequence seq = seqMeta.getSequence(); - if (seq == null) return; - - String schema = getPhisicalSchema(seq.getSchema()); - st.execute("DROP SEQUENCE IF EXISTS "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(seq.getName())); - - } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); - } finally { - st.close(); - } - - } - -} +package ru.fusionsoft.dbgit.postgres; + +import java.sql.Connection; +import java.util.Map; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBFunction; +import ru.fusionsoft.dbgit.dbobjects.DBSequence; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaFunction; +import ru.fusionsoft.dbgit.meta.MetaSequence; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +public class DBRestoreSequencePostgres extends DBRestoreAdapter { + + @Override + public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSeq").withParams(obj.getName()), 1); + try { + if (obj instanceof MetaSequence) { + MetaSequence restoreSeq = (MetaSequence)obj; + Map seqs = adapter.getSequences(((MetaSequence) obj).getSequence().getSchema()); + boolean exist = false; + if(!(seqs.isEmpty() || seqs == null)) { + for(DBSequence seq:seqs.values()) { + if(restoreSeq.getSequence().getName().equals(seq.getName())){ + String query=""; + exist = true; + String sequence = restoreSeq.getSequence().getSchema()+ "." +restoreSeq.getSequence().getName(); + if(!restoreSeq.getSequence().getOptions().get("cycle_option").equals(seq.getOptions().get("cycle_option"))) { + if(restoreSeq.getSequence().getOptions().get("cycle_option").equals("YES")) { + query+="alter sequence "+sequence + " cycle;\n"; + } + else { + query+="alter sequence "+sequence + " no cycle;\n"; + } + } + + if(!restoreSeq.getSequence().getOptions().get("increment").equals(seq.getOptions().get("increment"))) { + query+="alter sequence "+sequence+ " increment "+restoreSeq.getSequence().getOptions().get("increment")+";\n"; + } + + if(!restoreSeq.getSequence().getOptions().get("start_value").equals(seq.getOptions().get("start_value"))) { + query+="alter sequence "+sequence+" start "+restoreSeq.getSequence().getOptions().get("start_value")+";\n"; + } + + if(!restoreSeq.getSequence().getOptions().get("minimum_value").equals(seq.getOptions().get("minimum_value"))) { + query+="alter sequence "+sequence+ " minvalue "+restoreSeq.getSequence().getOptions().get("minimum_value")+";\n"; + } + + if(!restoreSeq.getSequence().getOptions().get("maximum_value").equals(seq.getOptions().get("maximum_value"))) { + query+="alter sequence "+sequence + " maxvalue "+restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; + } + + if(!restoreSeq.getSequence().getOptions().get("owner").equals(seq.getOptions().get("owner"))) { + if(seq.getOptions().get("blocking_table") != null){ + String tableName = DBAdapterPostgres.escapeNameIfNeeded(seq.getOptions().get("blocking_table").getData()); + query+="alter table "+tableName+ " owner to "+restoreSeq.getSequence().getOptions().get("owner")+";\n"; + } + query+="alter sequence "+sequence+" owner to "+restoreSeq.getSequence().getOptions().get("owner")+";\n"; + } + if(query.length()>1) { + st.execute(query); + } + //TODO Восстановление привилегий + } + } + } + if(!exist){ + String query=""; + String seqName = restoreSeq.getSequence().getName(); + String schema = restoreSeq.getSequence().getSchema(); + if(restoreSeq.getSequence().getOptions().get("cycle_option").equals("YES")){ + query+="create sequence \"" + schema + "\".\"" + seqName+"\"" + + "cycle \n"+ + "increment" + restoreSeq.getSequence().getOptions().get("increment")+"\n"+ + "start " + restoreSeq.getSequence().getOptions().get("start_value")+"\n"+ + "minvalue "+ restoreSeq.getSequence().getOptions().get("minimum_value")+"\n"+ + "maxvalue " + restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; + query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to\""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; + } + else { + query+="create sequence \"" + schema + "\".\"" + seqName+"\"" + + " no cycle \n"+ + "increment " + restoreSeq.getSequence().getOptions().get("increment")+"\n"+ + "start " + restoreSeq.getSequence().getOptions().get("start_value")+"\n"+ + "minvalue "+ restoreSeq.getSequence().getOptions().get("minimum_value")+"\n"+ + "maxvalue " + restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; + query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to \""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; + } + st.execute(query); + //TODO Восстановление привилегий + } + } + else + { + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + } + } catch (Exception e) { + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + st.close(); + } + return true; + } + + @Override + public void removeMetaObject(IMetaObject obj) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + + try { + if(! (obj instanceof MetaSequence)) throw new ExceptionDBGit("Wrong IMetaObject type, expected: seq, was: " + obj.getType().getValue()); + MetaSequence seqMeta = (MetaSequence) obj; + DBSequence seq = seqMeta.getSequence(); + if (seq == null) return; + + String schema = getPhisicalSchema(seq.getSchema()); + st.execute("DROP SEQUENCE IF EXISTS "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(seq.getName())); + + } catch (Exception e) { + ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); + } finally { + st.close(); + } + + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 838f8b6..845d6a4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -65,21 +65,29 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception if(existingTable.loadFromDB()){ StringProperties exTablespace = existingTable.getTable().getOptions().get("tablespace"); StringProperties restoreTablespace = restoreTable.getTable().getOptions().get("tablespace"); - if( - restoreTablespace != null && ( exTablespace == null || !exTablespace.getData().equals(restoreTablespace.getData()) ) - ){ + if(restoreTablespace != null && + ( exTablespace == null || !exTablespace.getData().equals(restoreTablespace.getData()) ) ){ //TODO For now in postgres context tablespace is always missing! - String restoreTablespaceSam = MessageFormat.format( - "alter table {0}.{1} set tablespace {2}" - ,schema - ,tblName - ,restoreTable.getTable().getOptions().getChildren().containsKey("tablespace") - ? restoreTable.getTable().getOptions().get("tablespace").getData() - : "pg_default" + String alterTableDdl = MessageFormat.format( + "alter table {0}.{1} set tablespace {2};\n" + ,schema + ,tblName + ,restoreTable.getTable().getOptions().get("tablespace").getData() ); - st.execute(restoreTablespaceSam); + st.execute(alterTableDdl); } + StringProperties exOwner= existingTable.getTable().getOptions().get("owner"); + StringProperties restoreOwner = restoreTable.getTable().getOptions().get("owner"); + if(restoreOwner != null && ( exOwner == null || !exOwner.getData().equals(restoreOwner.getData()) ) ){ + String alterTableDdl = MessageFormat.format( + "alter table {0}.{1} owner to {2};\n" + ,schema + ,tblName + ,restoreTable.getTable().getOptions().get("owner").getData() + ); + st.execute(alterTableDdl); + } ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); } else { ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "createTable"), 2); From 49ce7b7b36f0f0782f34681225e8c4bde9b44909 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 21:19:05 +0300 Subject: [PATCH 13/68] DBRestoreProcedurePostgres, DBRestoreFunctionPostgres comparison and restore arguments errors fix --- .../postgres/DBRestoreFunctionPostgres.java | 36 +++++++++---------- .../postgres/DBRestoreProcedurePostgres.java | 30 +++++++--------- 2 files changed, 28 insertions(+), 38 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java index 1270e75..4073388 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java @@ -1,6 +1,7 @@ package ru.fusionsoft.dbgit.postgres; import java.sql.Connection; +import java.text.MessageFormat; import java.util.Map; import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; @@ -12,6 +13,7 @@ import ru.fusionsoft.dbgit.meta.MetaFunction; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.utils.StringProperties; public class DBRestoreFunctionPostgres extends DBRestoreAdapter { @@ -20,16 +22,17 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreFnc").withParams(obj.getName()), 1); try { if (obj instanceof MetaFunction) { + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreFnc").withParams(obj.getName()), 1); + MetaFunction restoreFunction = (MetaFunction)obj; - String restoreFunctionName = DBAdapterPostgres.escapeNameIfNeeded(restoreFunction.getSqlObject().getName()); + String restoreFunctionName = restoreFunction.getSqlObject().getName(); Map functions = adapter.getFunctions(restoreFunction.getSqlObject().getSchema()); boolean exist = false; if(!(functions.isEmpty() || functions == null)) { for(DBFunction fnc:functions.values()) { - if(restoreFunctionName.equals(DBAdapterPostgres.escapeNameIfNeeded(fnc.getName()))){ + if(restoreFunctionName.equals(fnc.getName())){ exist = true; //if codes differ @@ -41,23 +44,16 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } //if owners differ - if(!restoreFunction.getSqlObject().getOwner().equals(fnc.getOwner())) { - //without arguments - if(restoreFunction.getSqlObject().getOptions().get("arguments").getData() == null || restoreFunction.getSqlObject().getOptions().get("arguments").getData().isEmpty()) { - st.execute( - "ALTER FUNCTION "+ restoreFunctionName + "() OWNER TO " - + restoreFunction.getSqlObject().getOwner()) - ; - } - //with arguments - else { - st.execute( - "ALTER FUNCTION "+restoreFunctionName +"(" - + restoreFunction.getSqlObject().getOptions().get("arguments").getData() - + ") OWNER TO " + restoreFunction.getSqlObject().getOwner() - ); - } - } + if(!restoreFunction.getSqlObject().getOwner().equals(fnc.getOwner())) { + StringProperties restoreProcArgs = restoreFunction.getSqlObject().getOptions().get("arguments"); + String args = restoreProcArgs != null ? restoreProcArgs.getData().replaceAll("(\\w+ \\w+) (DEFAULT [^\\,\\n]+)(\\,|\\b)", "$1") : ""; + + st.execute(MessageFormat.format("ALTER FUNCTION {0}.{1}({2}) OWNER TO {3}" + , restoreFunction.getUnderlyingDbObject().getSchema() + , DBAdapterPostgres.escapeNameIfNeeded(restoreFunctionName) + , args + , restoreFunction.getSqlObject().getOwner())); + } //TODO Восстановление привилегий } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java index 2316c2f..97ff621 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java @@ -10,6 +10,7 @@ import ru.fusionsoft.dbgit.meta.NameMeta; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.utils.StringProperties; import java.sql.Connection; import java.text.MessageFormat; @@ -22,17 +23,17 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restorePrc").withParams(obj.getName()), 1); try { if (obj instanceof MetaProcedure) { + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restorePrc").withParams(obj.getName()), 1); MetaProcedure restoreProc = (MetaProcedure)obj; NameMeta nm = new NameMeta(restoreProc); - String restoreProcName = DBAdapterPostgres.escapeNameIfNeeded(nm.getName()); + String restoreProcName = nm.getName(); Map procs = adapter.getProcedures(nm.getSchema()); boolean exist = false; if(!(procs.isEmpty() || procs == null)) { for(DBProcedure prc : procs.values()) { - if(restoreProcName.equals(DBAdapterPostgres.escapeNameIfNeeded(prc.getName()))){ + if(restoreProcName.equals(prc.getName())){ exist = true; //if codes differ @@ -45,21 +46,14 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { //if owners differ if(!restoreProc.getSqlObject().getOwner().equals(prc.getOwner())) { - //without arguments - if( restoreProc.getSqlObject().getOptions().get("arguments").getData() == null || - restoreProc.getSqlObject().getOptions().get("arguments").getData().isEmpty() - ) { - st.execute(MessageFormat.format("ALTER PROCEDURE {0}() OWNER TO {2}" - , restoreProcName - , restoreProc.getSqlObject().getOwner())); - } - //with arguments - else { - st.execute(MessageFormat.format("ALTER PROCEDURE {0}({1}) OWNER TO {2}" - , restoreProcName - , restoreProc.getSqlObject().getOptions().get("arguments").getData() - , restoreProc.getSqlObject().getOwner())); - } + StringProperties restoreProcArgs = restoreProc.getSqlObject().getOptions().get("arguments"); + String args = restoreProcArgs != null ? restoreProcArgs.getData().replaceAll("(\\w+ \\w+) (DEFAULT [^\\,\\n]+)(\\,|\\b)", "$1") : ""; + + st.execute(MessageFormat.format("ALTER PROCEDURE {0}.{1}({2}) OWNER TO {3}" + , nm.getSchema() + , DBAdapterPostgres.escapeNameIfNeeded(restoreProcName) + , args + , restoreProc.getSqlObject().getOwner())); } //TODO Восстановление привилегий } From 37780f83d0c08f768ec831f57a6a0fe63f803094 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 21:22:38 +0300 Subject: [PATCH 14/68] DBTableField comparison errors fix, also now it's aware of fixed, length, precision, scale options --- .../fusionsoft/dbgit/dbobjects/DBTableField.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java index e60bd5d..a8e2598 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java @@ -1,5 +1,6 @@ package ru.fusionsoft.dbgit.dbobjects; +import org.apache.http.annotation.Obsolete; import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -32,7 +33,13 @@ public String getHash() { CalcHash ch = new CalcHash(); ch.addData(this.getName()); ch.addData(this.getTypeSQL()); + ch.addData(this.getFixed()); + ch.addData(this.getLength()); + ch.addData(this.getPrecision()); + ch.addData(this.getScale()); if( this.getDefaultValue()!=null ) ch.addData(this.getDefaultValue()); + if( this.getIsNullable()!=null ) ch.addData(this.getIsNullable()); + // if( this.getOrder()!=null ) ch.addData(String.valueOf(this.getOrder())); ch.addData(isPrimaryKey.toString()); @@ -137,6 +144,14 @@ public int compareTo(DBTableField o) { if (res != 0) return res; return name.compareTo(o.getName()); } + + @Override public boolean equals(Object obj){ + boolean equals = obj == this; + if(!equals && obj instanceof DBTableField){ + return ((DBTableField) obj).getHash().equals(this.getHash()); + } + return equals; + } } From 5710f136f58efc6d697c7706910a1d7a7e802742 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 21:27:39 +0300 Subject: [PATCH 15/68] DBRestoreViewPostgres refactor and restore owner fix --- .../dbgit/postgres/DBRestoreViewPostgres.java | 55 +++++++++++-------- 1 file changed, 31 insertions(+), 24 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java index 6029966..7010c66 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java @@ -1,6 +1,7 @@ package ru.fusionsoft.dbgit.postgres; import java.sql.Connection; +import java.text.MessageFormat; import java.util.Map; import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; @@ -22,47 +23,29 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreView").withParams(obj.getName()), 1); try { if (obj instanceof MetaView) { - MetaView restoreView = (MetaView)obj; + MetaView restoreView = (MetaView)obj; Map views = adapter.getViews(restoreView.getSqlObject().getSchema()); boolean exist = false; - if(!(views.isEmpty() || views == null)) { + if(! (views == null || views.isEmpty())) { for(DBView vw:views.values()) { if(restoreView.getSqlObject().getName().equals(vw.getName())){ exist = true; if(!restoreView.getSqlObject().getSql().equals(vw.getSql())) { - //String ss = "CREATE OR REPLACE VIEW "+restoreView.getSqlObject().getName() +" AS\n"+restoreView.getSqlObject().getSql(); - st.execute(restoreView.getSqlObject().getName() +" AS\n"+restoreView.getSqlObject().getSql()); + st.execute(getDdlEscaped(restoreView)); } - if(!restoreView.getSqlObject().getOwner().equals(vw.getOwner())) { - st.execute("ALTER VIEW "+restoreView.getSqlObject().getName() +" OWNER TO "+restoreView.getSqlObject().getOwner()); + st.execute(getChangeOwnerDdl(restoreView, restoreView.getSqlObject().getOwner())); } - //TODO Восстановление привилегий } } } if(!exist){ - String query = restoreView.getSqlObject().getSql(); - String name = restoreView.getSqlObject().getName(); - boolean nameShouldBeEscaped = name.contains(".") || Character.isUpperCase(name.codePointAt(0)); - if (nameShouldBeEscaped) { - query = query.replace( - "create or replace view " + restoreView.getSqlObject().getSchema() + "." + restoreView.getSqlObject().getName(), - "create or replace view " + restoreView.getSqlObject().getSchema() + ".\"" + restoreView.getSqlObject().getName() + "\""); - } - - if (!query.endsWith(";")) query = query + ";"; - query = query + "\n"; - - query+= "ALTER VIEW "+ restoreView.getSqlObject().getSchema() + "." - + ( nameShouldBeEscaped ?( "\"" + name + "\"") : name) - + " OWNER TO "+restoreView.getSqlObject().getOwner()+";\n"; + String query = getDdlEscaped(restoreView) + getChangeOwnerDdl(restoreView, restoreView.getSqlObject().getOwner()); st.execute(query); - //TODO Восстановление привилегий } + //TODO Восстановление привилегий ? } else { @@ -101,4 +84,28 @@ public void removeMetaObject(IMetaObject obj) throws Exception { } } + private String getDdlEscaped(MetaView view){ + String name = view.getSqlObject().getName(); + String schema = view.getSqlObject().getSchema(); + String query = view.getSqlObject().getSql(); + String nameEscaped = DBAdapterPostgres.escapeNameIfNeeded(name); + + if (!name.equalsIgnoreCase(nameEscaped)) { + query = query.replace( + "create or replace view " + schema + "." + name, + "create or replace view " + schema + "." + nameEscaped + ); + } + if (!query.endsWith(";")) query = query + ";\n"; + query = query + "\n"; + return query; + } + + private String getChangeOwnerDdl(MetaView view, String owner){ + return MessageFormat.format("ALTER VIEW {0}.{1} OWNER TO {2}\n" + , view.getSqlObject().getSchema() + , DBAdapterPostgres.escapeNameIfNeeded(view.getSqlObject().getName()) + , owner + ); + } } From ee614f080fa9d97706de105c6f7d0eff2dca3ec8 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 21:36:14 +0300 Subject: [PATCH 16/68] ExceptionDBGit, ExceptionDBGitRunTime rethink and refactor, so only ctors with only Throwable argument propagate, others call DBConnection.getInstance().getConnect().rollback() and System.exit(1), always print stackTrace in verbose mode only --- .../fusionsoft/dbgit/core/ExceptionDBGit.java | 27 +++++++++++++------ .../dbgit/core/ExceptionDBGitRunTime.java | 19 ++++++++++--- 2 files changed, 35 insertions(+), 11 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java index 58f3804..b0c7437 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java @@ -1,10 +1,13 @@ package ru.fusionsoft.dbgit.core; +import org.apache.commons.lang3.exception.ExceptionUtils; import org.slf4j.Logger; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; +import java.sql.SQLException; + /** * Base class for all Exception in dbgit project * @@ -17,27 +20,35 @@ public class ExceptionDBGit extends Exception { private Logger logger = LoggerUtil.getLogger(this.getClass()); public ExceptionDBGit(Object msg) { - ConsoleWriter.printlnRed(msg); - System.exit(1); - //super(msg); + this(msg.toString()); } public ExceptionDBGit(String msg) { - ConsoleWriter.printlnRed(msg); - System.exit(1); - //super(msg); + this(msg, new Exception(msg)); } public ExceptionDBGit(String message, Throwable cause) { + super(message, cause); + logger.error(message, cause); + try{ + DBConnection conn = DBConnection.getInstance(); + conn.getConnect().rollback(); + } catch (Exception ex) { + if(ex instanceof ExceptionDBGit || ex instanceof SQLException) { + ConsoleWriter.detailsPrintlnRed("Failed to rollback connection: " + ex.getLocalizedMessage()); + } else { + ConsoleWriter.printlnRed(ex.getLocalizedMessage()); + } + } ConsoleWriter.printlnRed(message); + ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(cause)); logger.error(message, cause); System.exit(1); - //super(message, cause); } public ExceptionDBGit(Throwable cause) { + super(cause); logger.error(cause.getLocalizedMessage(), cause); - //super(cause); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java index f730db4..60ae571 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java @@ -1,10 +1,12 @@ package ru.fusionsoft.dbgit.core; +import org.apache.commons.lang3.exception.ExceptionUtils; import org.slf4j.Logger; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; +import java.sql.SQLException; public class ExceptionDBGitRunTime extends RuntimeException { private static final long serialVersionUID = 958722213419205629L; @@ -15,15 +17,26 @@ public ExceptionDBGitRunTime(String msg) { } public ExceptionDBGitRunTime(String message, Throwable cause) { + try{ + DBConnection conn = DBConnection.getInstance(); + conn.getConnect().rollback(); + //super(message, cause); + } catch (Exception ex) { + if(ex instanceof ExceptionDBGit || ex instanceof SQLException) { + ConsoleWriter.detailsPrintlnRed("Failed to rollback connection: " + ex.getLocalizedMessage()); + } else { + ConsoleWriter.printlnRed(ex.getLocalizedMessage()); + } + } ConsoleWriter.printlnRed(message); + ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(cause)); logger.error(message, cause); System.exit(1); - //super(message, cause); + } public ExceptionDBGitRunTime(Throwable cause) { - //super(cause); - logger.error(cause.getLocalizedMessage(), cause); + this(cause.getLocalizedMessage(), cause); } } From e90c01a683fda4925ade76e7942a5d742afe6f2d Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 23:41:17 +0300 Subject: [PATCH 17/68] Detailed messages revision, some comments --- .../dbgit/data_table/MapFileData.java | 21 ++++++++++++--- .../fusionsoft/dbgit/data_table/RowData.java | 4 +-- .../dbgit/dbobjects/DBSQLObject.java | 13 +++++++++- .../fusionsoft/dbgit/dbobjects/DBTable.java | 7 ++++- .../fusionsoft/dbgit/meta/MetaTableData.java | 26 ++++++++++++++++--- .../dbgit/oracle/DBRestorePackageOracle.java | 2 +- .../postgres/DBBackupAdapterPostgres.java | 8 +++--- .../postgres/DBRestoreSequencePostgres.java | 3 ++- .../postgres/DBRestoreTablePostgres.java | 5 ++-- .../fusionsoft/dbgit/utils/ConsoleWriter.java | 5 ++++ src/main/resources/lang/eng.yaml | 6 ++++- 11 files changed, 77 insertions(+), 23 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java index 7930114..25cc2cd 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java @@ -5,6 +5,8 @@ import java.nio.file.Files; import java.nio.file.StandardCopyOption; import java.sql.ResultSet; +import java.util.HashSet; +import java.util.Set; import ru.fusionsoft.dbgit.core.DBGit; import ru.fusionsoft.dbgit.core.DBGitLang; @@ -18,6 +20,7 @@ public class MapFileData implements ICellData { private String srcFile = null; private File tmpFile = null; + private static Set filesNotFound = new HashSet<>(); //private String hash = null; public InputStream getBlobData(ResultSet rs, String fieldname) throws Exception { @@ -52,9 +55,15 @@ public String serialize(DBTable tbl) throws Exception { @Override public void deserialize(String data) throws Exception { - File fp = new File(DBGitPath.getFullPath()+"/"+data); - if (fp.exists()) { - this.srcFile = data; + if(data != null){ + File fp = new File(DBGitPath.getFullPath()+"/"+data); + if (fp.exists()) { + this.srcFile = data; + } else { + int lastIndex = data.lastIndexOf('/'); + lastIndex = lastIndex == 0 ? data.lastIndexOf('\\') : lastIndex; + filesNotFound.add(data.substring(0, lastIndex)); + } } } @@ -75,7 +84,7 @@ public String getHash() throws Exception { if (srcFile != null) path = DBGitPath.getFullPath()+"/"+srcFile; if (path == null) return ""; - + CalcHash ch = new CalcHash(); ch.addDataFile(path); hash = ch.calcHashStr(); @@ -111,6 +120,10 @@ public String getSQLData() { public File getFile() throws ExceptionDBGit { return new File(DBGitPath.getFullPath() + srcFile); } + + public static Set getFilesNotFound(){ + return filesNotFound; + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java index 8a72cd5..abf313e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java @@ -85,13 +85,13 @@ private void loadDataFromCSVRecord(CSVRecord record, CSVRecord titleColumns, Met if (record.size() != titleColumns.size()) { throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "dataTable", "differentCount")); } - + for (int i = 0; i < record.size(); i++) { String columnName = titleColumns.get(i); if (metaTable.getFieldsMap().get(columnName) == null) { throw new ExceptionDBGitRunTime(DBGitLang.getInstance().getValue("errors", "dataTable", "fieldNotFound").withParams(columnName)); } - + ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); cd.deserialize(record.get(i)); diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java index 6305c8f..6a63941 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java @@ -19,7 +19,18 @@ public class DBSQLObject extends DBSchemaObject { private StringProperties options = new StringProperties(); public String getHash() { - CalcHash ch = new CalcHash(); + CalcHash ch = new CalcHash();/*{ + @Override public CalcHash addData(String data){ + ConsoleWriter.detailsPrintlnGreen("CH| " + data); + return super.addData(data); + } + @Override public String calcHashStr(){ + String result = super.calcHashStr(); + ConsoleWriter.detailsPrintlnRed("RES| " + result + "\n"); + return result; + } + + };*/ ch.addData(getSchema()); ch.addData(getName()); ch.addData(getSql().trim().replaceAll("\\s+", "")); diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java index 36beb5a..38f1b7d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java @@ -27,7 +27,12 @@ public void setOptions(StringProperties options) { } public String getHash() { - CalcHash ch = new CalcHash(); + CalcHash ch = new CalcHash()/*{ + public CalcHash addData(String str){ + ConsoleWriter.detailsPrintlnRed(str); + return super.addData(str); + } + }*/; ch.addData(this.getName()); ch.addData(this.getOptions().toString().replaceAll("\\s+", "")); diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index 93943fd..116b7ac 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -36,6 +36,7 @@ import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.core.GitMetaDataManager; import ru.fusionsoft.dbgit.data_table.ICellData; +import ru.fusionsoft.dbgit.data_table.MapFileData; import ru.fusionsoft.dbgit.data_table.RowData; import ru.fusionsoft.dbgit.data_table.TreeMapRowData; import ru.fusionsoft.dbgit.dbobjects.DBTable; @@ -142,6 +143,7 @@ public MetaTable getMetaTableFromFile() throws ExceptionDBGit { if (metaTable != null) return metaTable; + //TODO ... which is not from file, but from db return getMetaTable(); } @@ -177,13 +179,13 @@ public IMetaObject deSerialize(File file) throws Exception { CsvReader csvReader = new CsvReader(); csvReader.setFieldSeparator(';'); + int i = 1; try (CsvParser csvParser = csvReader.parse(file, StandardCharsets.UTF_8)) { CsvRow row; boolean flag = false; mapRows = new TreeMapRowData(); CsvRow titleColumns = null; - int i = 1; while ((row = csvParser.nextRow()) != null) { @@ -193,14 +195,18 @@ public IMetaObject deSerialize(File file) throws Exception { } else { RowData rd = new RowData(row, metaTable, titleColumns); mapRows.put(rd); - ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("general", "meta", "loadRow") + ": "+ i); -// System.out.println("row: " + i); i++; } flag = true; } + } catch (Throwable ex){ + ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance().getValue("general", "meta", "loadRow").withParams(String.valueOf(i) )); + warnFilesNotFound(); + throw ex; } - System.out.println("TableData loaded!"); + ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "meta", "loadedRow").withParams(String.valueOf(i) )); + warnFilesNotFound(); + return this; } @@ -431,4 +437,16 @@ public int removeFromGit() throws ExceptionDBGit { public List getFields() { return fields; } + + private void warnFilesNotFound(){ + Set filesNotFound = MapFileData.getFilesNotFound(); + if(filesNotFound != null && filesNotFound.size() > 0){ + ConsoleWriter.detailsPrintColor( + DBGitLang.getInstance().getValue("errors", "dataTable", "filesNotFound") + .withParams(String.join(";", filesNotFound)), 0, FColor.YELLOW + ); + filesNotFound.clear(); + } + + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java index 3a020f1..2d5aea9 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java @@ -24,7 +24,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { Connection connect = adapter.getConnection(); st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restorePkg").withParams(obj.getName()), 1); - try { + try { if (obj instanceof MetaPackage) { MetaPackage restorePackage = (MetaPackage) obj; Map pkgs = adapter.getPackages(restorePackage.getSqlObject().getSchema()); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java index d14695f..95f692a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java @@ -68,25 +68,23 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio String tableSamRe = schema + "\\.\\\"?" + Pattern.quote(tableName) + "\\\"?"; if(!isExists(schema, tableName)) { + //so don't actually backup, as I see... File file = new File(DBGitPath.getFullPath() + metaTable.getFileName()); if (file.exists()) obj = metaTable.loadFromFile(); return obj; } - if (isSaveToSchema()) { - createSchema(stLog, schema); - } + if (isSaveToSchema()) { createSchema(stLog, schema); } ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), 1); - StringBuilder tableDdlSb = new StringBuilder(MessageFormat.format( "create table {0} as (select * from {1}.{2} where 1={3}) {4};\n alter table {0} owner to {5};\n" , backupTableSam , DBAdapterPostgres.escapeNameIfNeeded(schema) , DBAdapterPostgres.escapeNameIfNeeded(tableName) - , isToSaveData() ? "1" : "0" + , isToSaveData() ? "1" : "0" //TableData , metaTable.getTable().getOptions().getChildren().containsKey("tablespace") ? " tablespace " + metaTable.getTable().getOptions().get("tablespace").getData() : "" diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java index 5694b21..8576957 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java @@ -69,6 +69,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if(query.length()>1) { st.execute(query); } + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); //TODO Восстановление привилегий } } @@ -108,7 +109,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 845d6a4..f2d0b00 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -122,7 +122,7 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception String tblSam = DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(tblName); if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addColumns"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addColumns"), 0); Comparator comparator = Comparator.comparing(DBTableField::getOrder); @@ -397,9 +397,9 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 1); try { if (obj instanceof MetaTable) { + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTableConstraints").withParams(obj.getName()), 1); MetaTable restoreTable = (MetaTable)obj; MetaTable existingTable = new MetaTable(restoreTable.getTable()); existingTable.loadFromDB(); @@ -444,7 +444,6 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); st.close(); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java b/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java index 701cf7f..0db3638 100644 --- a/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java +++ b/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java @@ -19,6 +19,11 @@ public static void detailsPrintLn(Object msg) { println(msg.toString()); } + public static void detailsPrintColor(Object msg, int level, FColor color) { + if (showDetailedLog) + printColor(msg.toString(), color, level); + } + public static void detailsPrint(Object msg, int level) { if (showDetailedLog) print(msg.toString(), level); diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index 9cb282d..d5b6eb1 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -115,7 +115,8 @@ general: diffSize1: MetaTableData diff size!!! {0} {1} diffSize2: MetaTableData diff size row {0}!!! diffDataRow: MetaTableData diff data row {0} {1} {2} {3} - loadRow: Loading row + loadRow: loading row {0} + loadedRow: loaded {0} rows backup: tryingToCopy: Trying to copy {0} to {1}... creatingSchema: Creating schema {0} @@ -192,6 +193,7 @@ errors: errorCellData: Error create CellData for type {0} differentCount: Different count columns title and line fieldNotFound: Field {0} not found + filesNotFound: Cound not find .data files in directories '{0}', put NULL values instead adapter: schemes: Error load schemes! tables: Error load tables! @@ -252,6 +254,7 @@ help: Example: dbgit link jdbc:oracle:thin:@:: user= password= link-d: Creates default dblink file + link-ls: Just see current db url backup: | Examples: dbgit backup / -d -s @@ -269,6 +272,7 @@ help: checkout-b: create and checkout a new branch checkout-r: Updates database checkout-u: Upgrades branch to actual db and dbgit version state + checkout-ls: Just see current branch, head and revision number checkout-no-db: Doesn't do restore after checkout clone: | Example: From 70783b9a95b681f44c2dd16738d304ec4c4cb1c9 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Sep 2020 23:47:39 +0300 Subject: [PATCH 18/68] DBRestoreTableDataPostgres refactor Rework behavior puts '' instead of null in text fields if cant find .data file - some compatibility with old dumps --- .../postgres/DBRestoreTableDataPostgres.java | 293 +++++++++--------- 1 file changed, 142 insertions(+), 151 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index 61bdb78..0f3dd66 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -1,17 +1,14 @@ package ru.fusionsoft.dbgit.postgres; import java.io.BufferedReader; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; -import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStreamReader; -import java.sql.Clob; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; +import java.text.MessageFormat; import java.text.SimpleDateFormat; import java.util.*; import java.util.stream.Collectors; @@ -36,6 +33,7 @@ import ru.fusionsoft.dbgit.meta.IMetaObject; import ru.fusionsoft.dbgit.meta.MetaTable; import ru.fusionsoft.dbgit.meta.MetaTableData; +import ru.fusionsoft.dbgit.meta.NameMeta; import ru.fusionsoft.dbgit.statement.PrepareStatementLogging; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -55,8 +53,8 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { //TODO не факт что в кеше есть мета описание нашей таблицы, точнее ее не будет если при старте ресторе таблицы в бд не было совсем IMetaObject currentMetaObj = gitMetaMng.getCacheDBMetaObject(obj.getName()); - - if (currentMetaObj instanceof MetaTableData || currentMetaObj == null) { + + if (currentMetaObj == null || currentMetaObj instanceof MetaTableData) { if(Integer.valueOf(step).equals(0)) { removeTableConstraintsPostgres(restoreTableData.getMetaTable()); @@ -76,9 +74,11 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { currentTableData.setMapRows(new TreeMapRowData()); currentTableData.setDataTable(restoreTableData.getDataTable()); } + //clears restoreTableData->getDataTable() too after ^ "else" clause currentTableData.getmapRows().clear(); if (getAdapter().getTable(schema, currentTableData.getTable().getName()) != null) { + //actually load data from database currentTableData.setDataTable(getAdapter().getTableData(schema, currentTableData.getTable().getName())); ResultSet rs = currentTableData.getDataTable().getResultSet(); @@ -86,6 +86,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { TreeMapRowData mapRows = new TreeMapRowData(); MetaTable metaTable = new MetaTable(currentTableData.getTable()); + //ALSO loads data from database if fields vary metaTable.loadFromDB(currentTableData.getTable()); if (rs != null) { @@ -124,187 +125,149 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } } - public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ + public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTableData").withParams(restoreTableData.getName()), 1); + List fieldsList = restoreTableData.getFields(); + if(fieldsList.size() == 0 ) { + ConsoleWriter.detailsPrintlnRed("Empty fieldList, maybe empty csv"); + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + return; + } + if (restoreTableData.getmapRows() == null) { + ConsoleWriter.detailsPrintlnRed("MapRows is null, maybe empty csv"); + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + return; + } + IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { - if (restoreTableData.getmapRows() == null) - restoreTableData.setMapRows(new TreeMapRowData()); - - String fields = ""; - if (restoreTableData.getmapRows().size() > 0) { - //fields = keysToString(restoreTableData.getmapRows().firstEntry().getValue().getData().keySet().stream().map(DBAdapterPostgres::escapeNameIfNeeded).collect(Collectors.toSet())) + " values "; - Comparator comparator = Comparator.comparing(DBTableField::getOrder); - fields = "(" + restoreTableData.getMetaTableFromFile().getFields().entrySet().stream() - .sorted(Comparator.comparing(e -> e.getValue().getOrder())) - .map(entry -> DBAdapterPostgres.escapeNameIfNeeded(entry.getValue().getName())) - .collect(Collectors.joining(", ")) - + ") values "; + MapDifference diffTableData = Maps.difference(restoreTableData.getmapRows(), currentTableData.getmapRows()); + try (StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql())) { - } - - List fieldsList = restoreTableData.getFields(); - - MapDifference diffTableData = Maps.difference(restoreTableData.getmapRows(),currentTableData.getmapRows()); String schema = getPhisicalSchema(restoreTableData.getTable().getSchema()); - - schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); - String tblNameUnescaped = schema + "." + restoreTableData.getTable().getName(); String tblNameEscaped = DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(restoreTableData.getTable().getName()); + String fields = getFieldsPrefix(restoreTableData); + Map colTypes = getColumnDataTypes(restoreTableData.getMetaTable(), st); + Set keyNames = restoreTableData.getMetaTable().getFields().values().stream() + .filter(DBTableField::getIsPrimaryKey) + .map(DBTableField::getName) + .collect(Collectors.toSet()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "tableData").withParams(tblNameUnescaped) + "\n", 1); - - ResultSet rsTypes = st.executeQuery("select column_name, data_type from information_schema.columns \r\n" + - "where lower(table_schema||'.'||table_name) = lower('" + tblNameUnescaped + "')"); - HashMap colTypes = new HashMap(); - while (rsTypes.next()) { - colTypes.put(rsTypes.getString("column_name"), rsTypes.getString("data_type")); - } - - - if(!diffTableData.entriesOnlyOnLeft().isEmpty()) { - - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 2); - - for(RowData rowData:diffTableData.entriesOnlyOnLeft().values()) { - //ArrayList fieldsList = new ArrayList(rowData.getData().keySet().stream().map(DBAdapterPostgres::escapeNameIfNeeded).collect(Collectors.toList())); + //DELETE + if (!diffTableData.entriesOnlyOnRight().isEmpty()) { + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 2); + StringBuilder deleteQuery = new StringBuilder(); - String insertQuery = "insert into " + tblNameEscaped + - fields+valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) + ";\n"; - - ConsoleWriter.detailsPrintLn(insertQuery); - - PrepareStatementLogging ps = new PrepareStatementLogging(connect, insertQuery, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + for (RowData rowData : diffTableData.entriesOnlyOnRight().values()) { + StringJoiner fieldJoiner = new StringJoiner(","); + StringJoiner valuejoiner = new StringJoiner(","); - st.execute(insertQuery); - } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - } - - if(!diffTableData.entriesOnlyOnRight().isEmpty()){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 2); - String deleteQuery=""; - Map primarykeys = new HashMap(); - for(RowData rowData:diffTableData.entriesOnlyOnRight().values()) { - Map tempcols = rowData.getData(fieldsList); - String[] keysArray = rowData.getKey().split("_"); - for(String key:keysArray) { - for (String o : tempcols.keySet()) { - if (tempcols.get(o) == null || tempcols.get(o).convertToString() == null) continue; - if (tempcols.get(o).convertToString().equals(key)) { - primarykeys.put(o, tempcols.get(o).convertToString()); - tempcols.remove(o); - break; - } + for( Map.Entry entry : rowData.getData(fieldsList).entrySet()) { + if (keyNames.contains(entry.getKey())) { + fieldJoiner.add("\"" + entry.getKey() + "\""); + valuejoiner.add(entry.getValue().convertToString()); } } - String delFields="("; - String delValues="("; - StringJoiner fieldJoiner = new StringJoiner(","); - StringJoiner valuejoiner = new StringJoiner(","); - for (Map.Entry entry : primarykeys.entrySet()) { - fieldJoiner.add("\""+entry.getKey()+"\""); - valuejoiner.add("\'"+entry.getValue()+"\'"); + + String delFields = "(" + fieldJoiner.toString() + ")"; + String delValues = "(" + valuejoiner.toString() + ")"; + + if (delValues.length() > 3){ + deleteQuery.append("DELETE FROM ").append(tblNameEscaped) + .append(" WHERE ").append(delFields).append(" = ") + .append(delValues).append(";\n"); } - delFields+=fieldJoiner.toString()+")"; - delValues+=valuejoiner.toString()+")"; - primarykeys.clear(); - if (delValues.length() > 3) - deleteQuery+="delete from " + tblNameUnescaped+ - " where " + delFields + " = " + delValues + ";\n"; - if(deleteQuery.length() > 50000 ){ - st.execute(deleteQuery); - deleteQuery = ""; + if (deleteQuery.length() > 50000) { + st.execute(deleteQuery.toString()); + deleteQuery = new StringBuilder(); } } - if(deleteQuery.length()>1) { - st.execute(deleteQuery); + if (deleteQuery.length() > 1) { + st.execute(deleteQuery.toString()); } ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); } - - if(!diffTableData.entriesDiffering().isEmpty()) { + + //UPDATE + if (!diffTableData.entriesDiffering().isEmpty()) { ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 2); - String updateQuery=""; - Map primarykeys = new HashMap(); - for(ValueDifference diffRowData:diffTableData.entriesDiffering().values()) { - if(!diffRowData.leftValue().getHashRow().equals(diffRowData.rightValue().getHashRow())) { + String updateQuery = ""; + Map primarykeys = new HashMap(); + + for (ValueDifference diffRowData : diffTableData.entriesDiffering().values()) { + if (!diffRowData.leftValue().getHashRow().equals(diffRowData.rightValue().getHashRow())) { + Map tempCols = diffRowData.leftValue().getData(fieldsList); - String[] keysArray = diffRowData.leftValue().getKey().split("_"); - for(String key:keysArray) { - for (String o : tempCols.keySet()) { - if (tempCols.get(o) == null || tempCols.get(o).convertToString() == null) continue; - if (tempCols.get(o).convertToString().equals(key)) { - primarykeys.put(o, tempCols.get(o).convertToString()); - tempCols.remove(o); - break; - } + for (String key : tempCols.keySet()) { + if (tempCols.get(key) == null || tempCols.get(key).convertToString() == null) continue; + if (keyNames.contains(key)) { + primarykeys.put(key, tempCols.get(key).convertToString()); + tempCols.remove(key); } } - if(!tempCols.isEmpty()) { - String keyFields="("; - String keyValues="("; - StringJoiner fieldJoiner = new StringJoiner(","); - StringJoiner valuejoiner = new StringJoiner(","); - for (Map.Entry entry : primarykeys.entrySet()) { - fieldJoiner.add("\""+entry.getKey()+"\""); - valuejoiner.add("\'"+entry.getValue()+"\'"); + + + if (!tempCols.isEmpty()) { + StringJoiner keyFieldsJoiner = new StringJoiner(","); + StringJoiner keyValuesJoiner = new StringJoiner(","); + for (Map.Entry entry : primarykeys.entrySet()) { + keyFieldsJoiner.add("\"" + entry.getKey() + "\""); + keyValuesJoiner.add("\'" + entry.getValue() + "\'"); } - keyFields+=fieldJoiner.toString()+")"; - keyValues+=valuejoiner.toString()+")"; primarykeys.clear(); - - StringJoiner updfieldJoiner = new StringJoiner(","); - StringJoiner updvaluejoiner = new StringJoiner(","); - String updFields="("; - String updValues="("; - - for (Map.Entry entry : tempCols.entrySet()) { - updfieldJoiner.add("\""+entry.getKey()+"\""); - //updvaluejoiner.add("\'"+entry.getValue().convertToString()+"\'"); - //updvaluejoiner.add("?"); - } - - //ArrayList fieldsList = new ArrayList(diffRowData.leftValue().getData().keySet()); - - updFields+=updfieldJoiner.toString()+")"; - updValues+=updvaluejoiner.toString()+")"; - - updateQuery="update "+tblNameEscaped+ - " set "+updFields + " = " + valuesToString(tempCols.values(), colTypes, fieldsList) + " where " + keyFields+ "=" +keyValues+";\n"; - + + + StringJoiner updFieldJoiner = new StringJoiner(","); + tempCols.forEach( (key, value) -> { + updFieldJoiner.add("\"" + key + "\""); + }); + + + updateQuery = "UPDATE " + tblNameEscaped + " SET (" + updFieldJoiner.toString() + ") = " + + valuesToString(tempCols.values(), colTypes, fieldsList) + " " + + "WHERE (" + keyFieldsJoiner.toString() + ") = (" + keyValuesJoiner.toString() + ");\n"; + + ConsoleWriter.detailsPrintLn(updateQuery); - - PrepareStatementLogging ps = new PrepareStatementLogging(connect, updateQuery, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - - //if(updateQuery.length() > 50000 ){ - st.execute(updateQuery); - updateQuery = ""; - //} - + st.execute(updateQuery); + updateQuery = ""; } - + } } + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - if(updateQuery.length()>1) { + if (updateQuery.length() > 1) { ConsoleWriter.println(updateQuery); st.execute(updateQuery); } - } - + } + + //INSERT + if (!diffTableData.entriesOnlyOnLeft().isEmpty()) { + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 2); + for (RowData rowData : diffTableData.entriesOnlyOnLeft().values()) { + + String insertQuery = MessageFormat.format("INSERT INTO {0}{1}{2};\n" + , tblNameEscaped, fields + , valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) + ); + + ConsoleWriter.detailsPrintLn(insertQuery); + st.execute(insertQuery); + } + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + } + } catch (Exception e) { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()), e); - } finally { - st.close(); } } - public String valuesToString(Collection datas, HashMap colTypes, List fieldsList) throws ExceptionDBGit, IOException { + public String valuesToString(Collection datas, Map colTypes, List fieldsList) throws ExceptionDBGit, IOException { String values="("; StringJoiner joiner = new StringJoiner(","); int i = 0; @@ -313,7 +276,9 @@ public String valuesToString(Collection datas, HashMap keys) { } public void restoreTableConstraintPostgres(MetaTable table) throws Exception { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), 1); IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -584,4 +548,31 @@ public void removeMetaObject(IMetaObject obj) throws Exception { } + private String getFieldsPrefix(MetaTableData restoreTableData) throws ExceptionDBGit { + return MessageFormat.format("({0}) values " + , restoreTableData.getMetaTableFromFile().getFields().entrySet().stream() + .sorted(Comparator.comparing(e -> e.getValue().getOrder())) + .map(entry -> DBAdapterPostgres.escapeNameIfNeeded(entry.getValue().getName())) + .collect(Collectors.joining(", ")) + ); + } + + private Map getColumnDataTypes(MetaTable tbl, StatementLogging st) throws SQLException { + HashMap colTypes = new HashMap(); + NameMeta nm = new NameMeta(tbl); + nm.setSchema(nm.getSchema()); + + ResultSet rsTypes = st.executeQuery(MessageFormat.format( + " select column_name, data_type from information_schema.columns \r\n" + + " where lower(table_schema) = lower(''{0}'') AND lower(table_name) = lower(''{1}'')" + , nm.getSchema(), nm.getName() + )); + + while (rsTypes.next()) { + colTypes.put(rsTypes.getString("column_name"), rsTypes.getString("data_type")); + } + return colTypes; + } + + } From 13f678cbd1aea0068a0ab103a5b440fc711625e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=20?= =?UTF-8?q?=D0=93=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D0=BB=D0=BE=D0=B2?= Date: Fri, 25 Sep 2020 17:04:24 +0200 Subject: [PATCH 19/68] Add .gitlab-ci.yml --- .gitlab-ci.yml | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 .gitlab-ci.yml diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..e3ff603 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,18 @@ +image: maven:3.6.3-jdk-8 + +stages: +# - test + - build +# - deploy + +build: + stage: build + script: + - time mvn package appassembler:assemble -D skipTests + artifacts: + paths: + - target/dbgit + +cache: + paths: + - .m2/repository From 84c07afdb6bfc3c0d245924b2fdb3d1e3731237e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=20?= =?UTF-8?q?=D0=93=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D0=BB=D0=BE=D0=B2?= Date: Fri, 25 Sep 2020 17:07:14 +0200 Subject: [PATCH 20/68] Update pom.xml --- pom.xml | 532 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 266 insertions(+), 266 deletions(-) diff --git a/pom.xml b/pom.xml index 5d3197f..99c8d33 100644 --- a/pom.xml +++ b/pom.xml @@ -1,266 +1,266 @@ - - 4.0.0 - - ru.fusionsoft - dbgit - 0.3.1 - jar - - - - - org.apache.maven.plugins - maven-jar-plugin - 3.1.2 - - - - true - ru.fusionsoft.dbgit.App - - - - - - - org.codehaus.mojo - appassembler-maven-plugin - 1.5 - - - ${project.build.directory}/dbgit - - - ru.fusionsoft.dbgit.App - dbgit - - - -Dfile.encoding=UTF-8 - -Dlog4j.properties=false - - - - - - - - - - org.apache.maven.plugins - maven-compiler-plugin - 3.7.0 - - 1.8 - 1.8 - - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.9.1 - - -Xdoclint:none - - - - - - - - - ${project.basedir}/src/main/resources/scripts - ${project.build.directory}/dbgit - - dbgit-install-windows.bat - dbgit-install-linux.sh - dbgit-install-mac.sh - INSTALLER-README.txt - - - - ${project.basedir}/src/main/resources/scripts - ${project.build.directory}/dbgit/bin - - path-update.ps1 - git-download-x64.ps1 - git-download-x86.ps1 - path-parser.ps1 - - - - ${project.basedir}/src/main/resources/lang - ${project.build.directory}/dbgit/lang - - eng.yaml - rus.yaml - - - - ${project.basedir}/src/main/resources - ${project.build.directory}/dbgit - - dbgitconfig - - - - - - - dbgit - http://maven.apache.org - - - UTF-8 - UTF-8 - - - - - - junit - junit - 4.12 - test - - - - - - org.apache.commons - commons-lang3 - 3.0 - - - - - - org.slf4j - slf4j-api - 1.7.25 - - - - ch.qos.logback - logback-classic - 1.2.3 - - - - - org.yaml - snakeyaml - 1.20 - - - - - org.eclipse.jgit - org.eclipse.jgit - 4.11.0.201803080745-r - - - - com.axiomalaska - jdbc-named-parameters - 1.1 - - - - - com.diogonunes - JCDP - 2.0.3.1 - - - - - org.apache.commons - commons-csv - 1.5 - - - - - org.apache.commons - commons-io - 1.3.2 - - - - - commons-cli - commons-cli - 1.4 - - - - - - org.postgresql - postgresql - 42.2.5 - - - - - mysql - mysql-connector-java - 8.0.16 - - - - - com.google.collections - google-collections - 1.0 - - - - org.ini4j - ini4j - 0.5.1 - - - - org.codehaus.janino - janino - 3.0.6 - - - - com.oracle.jdbc - ojdbc8 - 18.3.0.0 - - - - com.microsoft.sqlserver - mssql-jdbc - 7.0.0.jre8 - - - - com.google.code.findbugs - jsr305 - 3.0.0 - - - - - - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.9.1 - - -Xdoclint:none - - - - - - + + 4.0.0 + + ru.fusionsoft + dbgit + 0.3.1 + jar + + + + + org.apache.maven.plugins + maven-jar-plugin + 3.1.2 + + + + true + ru.fusionsoft.dbgit.App + + + + + + + org.codehaus.mojo + appassembler-maven-plugin + 1.5 + + + ${project.build.directory}/dbgit + + + ru.fusionsoft.dbgit.App + dbgit + + + -Dfile.encoding=UTF-8 + -Dlog4j.properties=false + + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.7.0 + + 1.8 + 1.8 + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.9.1 + + -Xdoclint:none + + + + + + + + + ${project.basedir}/src/main/resources/scripts + ${project.build.directory}/dbgit + + dbgit-install-windows.bat + dbgit-install-linux.sh + dbgit-install-mac.sh + INSTALLER-README.txt + + + + ${project.basedir}/src/main/resources/scripts + ${project.build.directory}/dbgit/bin + + path-update.ps1 + git-download-x64.ps1 + git-download-x86.ps1 + path-parser.ps1 + + + + ${project.basedir}/src/main/resources/lang + ${project.build.directory}/dbgit/lang + + eng.yaml + rus.yaml + + + + ${project.basedir}/src/main/resources + ${project.build.directory}/dbgit + + dbgitconfig + + + + + + + dbgit + http://maven.apache.org + + + UTF-8 + UTF-8 + + + + + + junit + junit + 4.12 + test + + + + + + org.apache.commons + commons-lang3 + 3.0 + + + + + + org.slf4j + slf4j-api + 1.7.25 + + + + ch.qos.logback + logback-classic + 1.2.3 + + + + + org.yaml + snakeyaml + 1.20 + + + + + org.eclipse.jgit + org.eclipse.jgit + 4.11.0.201803080745-r + + + + com.axiomalaska + jdbc-named-parameters + 1.1 + + + + + com.diogonunes + JCDP + 2.0.3.1 + + + + + org.apache.commons + commons-csv + 1.5 + + + + + org.apache.commons + commons-io + 1.3.2 + + + + + commons-cli + commons-cli + 1.4 + + + + + + org.postgresql + postgresql + 42.2.5 + + + + + mysql + mysql-connector-java + 8.0.16 + + + + + com.google.collections + google-collections + 1.0 + + + + org.ini4j + ini4j + 0.5.1 + + + + org.codehaus.janino + janino + 3.0.6 + + + + com.oracle.ojdbc + ojdbc8 + 19.3.0.0 + + + + com.microsoft.sqlserver + mssql-jdbc + 7.0.0.jre8 + + + + com.google.code.findbugs + jsr305 + 3.0.0 + + + + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.9.1 + + -Xdoclint:none + + + + + + From 08907984238afa45148dfb05ea7b17423a6a06c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=20?= =?UTF-8?q?=D0=93=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D0=BB=D0=BE=D0=B2?= Date: Fri, 25 Sep 2020 17:10:29 +0200 Subject: [PATCH 21/68] Update .gitlab-ci.yml --- .gitlab-ci.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index e3ff603..b130f50 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -10,8 +10,9 @@ build: script: - time mvn package appassembler:assemble -D skipTests artifacts: + cwd: "target" paths: - - target/dbgit + - dbgit cache: paths: From 9b2f2428c92fe2f9564788cb157c1cbc7e9576dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=20?= =?UTF-8?q?=D0=93=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D0=BB=D0=BE=D0=B2?= Date: Fri, 25 Sep 2020 17:11:17 +0200 Subject: [PATCH 22/68] Update .gitlab-ci.yml --- .gitlab-ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index b130f50..905956a 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -11,6 +11,7 @@ build: - time mvn package appassembler:assemble -D skipTests artifacts: cwd: "target" + archive: dbgit.zip paths: - dbgit From 6ae0ba7c1fc0659f130dfa7e9beda2527886e5dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=20?= =?UTF-8?q?=D0=93=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D0=BB=D0=BE=D0=B2?= Date: Fri, 25 Sep 2020 17:18:05 +0200 Subject: [PATCH 23/68] Update .gitlab-ci.yml --- .gitlab-ci.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 905956a..cddc750 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -9,9 +9,8 @@ build: stage: build script: - time mvn package appassembler:assemble -D skipTests + - mv target/dbgit dbgit artifacts: - cwd: "target" - archive: dbgit.zip paths: - dbgit From 544a40082d0670684d3b7a1f60d1be11b70989b5 Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 18:08:51 +0300 Subject: [PATCH 24/68] CmdCheckout -ls option - shows current branch\commit name CmdCheckout -s option passthrough to CmdRestore CmdClone -directory option to select clone subdirectory --- .../fusionsoft/dbgit/command/CmdCheckout.java | 17 +++++++++-- .../ru/fusionsoft/dbgit/command/CmdClone.java | 11 ++++++-- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 28 ++++++++++--------- 3 files changed, 38 insertions(+), 18 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java index de9aa88..5577d70 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java @@ -57,10 +57,16 @@ public void execute(CommandLine cmdLine) throws Exception { if (cmdLine.hasOption("ls")){ try(RevWalk walk = new RevWalk(repo)){ + String branch = repo.getBranch(); + String headNumber = head.getObjectId().getName(); + String headName = head.getName(); + String message = walk.parseCommit(head.getObjectId()).getShortMessage(); + ConsoleWriter.printlnGreen(MessageFormat.format( - "{0}: {1} ({2}) - {3}", - repo.getBranch(), head.getObjectId().getName(), head.getName(), - walk.parseCommit(head.getObjectId()).getShortMessage() + "{0} ({1}) {2}", + !branch.equals(headNumber) ? branch + ": " + headName : headNumber, + headName, + message )); } return; @@ -96,6 +102,11 @@ public void execute(CommandLine cmdLine) throws Exception { if (cmdLine.hasOption("v")) { builder.addOption(new Option("v", false, "")); } + if (cmdLine.hasOption("s")) { + Option scriptOption = new Option("s", true, ""); + scriptOption.getValuesList().add(cmdLine.getOptionValue("s")); + builder.addOption(scriptOption); + } restoreCommand.execute(builder.build()); } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdClone.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdClone.java index 697407f..2d6b383 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdClone.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdClone.java @@ -6,10 +6,16 @@ import ru.fusionsoft.dbgit.core.DBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import java.io.File; + public class CmdClone implements IDBGitCommand { private Options opts = new Options(); - + + public CmdClone() { + opts.addOption("directory", false, "subdirectory to clone into"/*getLang().getValue("help", "commit-a").toString()*/); + } + @Override public String getCommandName() { return "clone"; @@ -36,6 +42,7 @@ public void execute(CommandLine cmdLine) throws Exception { String link = ""; String remote = ""; + File directory = cmdLine.hasOption("directory") ? new File(cmdLine.getOptionValue("directory")) : null; if (args.length > 2) { throw new ExceptionDBGit(getLang().getValue("errors", "paramsNumberIncorrect")); } else if (args.length == 1) { @@ -45,7 +52,7 @@ public void execute(CommandLine cmdLine) throws Exception { remote = args[1]; } - DBGit.gitClone(link, remote); + DBGit.gitClone(link, remote, directory); } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index 1f0550b..646e3b6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -5,18 +5,9 @@ import java.util.List; import java.util.Set; -import org.eclipse.jgit.api.CheckoutCommand; -import org.eclipse.jgit.api.FetchCommand; -import org.eclipse.jgit.api.Git; -import org.eclipse.jgit.api.InitCommand; +import org.eclipse.jgit.api.*; import org.eclipse.jgit.api.ListBranchCommand.ListMode; -import org.eclipse.jgit.api.MergeCommand; -import org.eclipse.jgit.api.MergeResult; -import org.eclipse.jgit.api.PullCommand; -import org.eclipse.jgit.api.RemoteAddCommand; -import org.eclipse.jgit.api.RemoteRemoveCommand; import org.eclipse.jgit.api.ResetCommand.ResetType; -import org.eclipse.jgit.api.Status; import org.eclipse.jgit.dircache.DirCache; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Ref; @@ -370,10 +361,17 @@ public static void gitInit(String dirPath) throws ExceptionDBGit { } } - public static void gitClone(String link, String remoteName) throws ExceptionDBGit { + public static void gitClone(String link, String remoteName, File directory) throws ExceptionDBGit { try { - Git.cloneRepository().setURI(link).setCredentialsProvider(getCredentialsProvider(link)) - .setRemote(remoteName.equals("") ? Constants.DEFAULT_REMOTE_NAME : remoteName).call(); + String actualRemoteName = remoteName.equals("") ? Constants.DEFAULT_REMOTE_NAME : remoteName; + CredentialsProvider cp = getCredentialsProvider(link); + CloneCommand cc = Git.cloneRepository() + .setURI(link) + .setRemote(actualRemoteName) + .setCredentialsProvider(cp) + .setDirectory(directory); + + cc.call(); ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "clone", "cloned")); @@ -499,6 +497,10 @@ private static CredentialsProvider getCredentialsProvider(String link) throws Ex ConsoleWriter.detailsPrintLn("login: " + login); ConsoleWriter.detailsPrintLn("pass: " + pass);*/ + if(uri.getUser() == null) { + ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance().getValue("errors", "gitLoginNotFound")); + return null; + } return new UsernamePasswordCredentialsProvider(uri.getUser(), uri.getPass()); } catch (Exception e) { throw new ExceptionDBGit(e); From 2feaf3cf7aaafeabe71ecf29b2427af0a1e5835e Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 22:08:30 +0300 Subject: [PATCH 25/68] GitMetaDataManager.loadDBMetaData(boolean includeBackupSchemas) version to ensure needed management mode of backup objects in 'BACKUP_TO_SCHEME=true' mode GitMetaDataManager.loadMetaFile(..., boolean forceLoad) variant - uses no MetaFile cache - now enabled by default DBGitIgnore.loadFileDBIgnore(boolean withBackupSchemas) variant - automatically duplicate .dbignore records with backup schemas to exclusions - disabled by default --- .../ru/fusionsoft/dbgit/core/DBGitIgnore.java | 22 +++++++++-- .../dbgit/core/GitMetaDataManager.java | 39 +++++++++---------- 2 files changed, 37 insertions(+), 24 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitIgnore.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitIgnore.java index ae735ed..e5c4330 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitIgnore.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitIgnore.java @@ -6,7 +6,7 @@ import java.util.HashMap; import java.util.Map; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.adapters.DBBackupAdapter; import ru.fusionsoft.dbgit.utils.MaskFilter; /** @@ -27,19 +27,35 @@ public class DBGitIgnore { // load file DBIgnore loadFileDBIgnore(); } - + + public DBGitIgnore(Map filters, Map exclusions) { + this.filters = filters; + this.exclusions = exclusions; + } + protected void loadFileDBIgnore() throws ExceptionDBGit { + loadFileDBIgnore(false); + } + protected void loadFileDBIgnore(boolean withBackupSchemas) throws ExceptionDBGit { try{ File file = new File(DBGitPath.getRootPath(DBGitPath.DB_GIT_PATH+"/"+DBGitPath.DB_IGNORE_FILE)); if (!file.exists()) return ; + //boolean isBackupToScheme = DBGitConfig.getInstance().getBoolean("core", "BACKUP_TO_SCHEME", false); BufferedReader br = new BufferedReader(new FileReader(file)); - for(String line; (line = br.readLine()) != null; ) { + for(String line; (line = br.readLine()) != null; ) { + if (line.startsWith("!")) { MaskFilter mask = new MaskFilter(line.substring(1)); exclusions.put(line.substring(1), mask); + if(withBackupSchemas /*&&isBackupToScheme*/){ + String schemaPart = line.substring(1,line.indexOf("/")+1); + String backupSchemeObjExclusion = line.replace(schemaPart, DBBackupAdapter.PREFIX + schemaPart).substring(1); + MaskFilter backupSchemeObjMask = new MaskFilter(backupSchemeObjExclusion); + exclusions.put(backupSchemeObjExclusion, backupSchemeObjMask); + } } else { MaskFilter mask = new MaskFilter(line); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java index 7d4a2a2..df7e609 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java @@ -157,12 +157,13 @@ public void setCurrentPortion(int currentPortionIndex) { * Load meta data from DB * @return */ - public IMapMetaObject loadDBMetaData(boolean toIgnore) throws ExceptionDBGit { + public IMapMetaObject loadDBMetaData(boolean includeBackupSchemas) throws ExceptionDBGit { IDBAdapter adapter = AdapterFactory.createAdapter(); - DBGitIgnore ignore = (toIgnore) - ? DBGitIgnore.getInstance() - : new DBGitIgnore() { @Override protected void loadFileDBIgnore() { }}; + DBGitIgnore ignore = (includeBackupSchemas) + ? new DBGitIgnore() { @Override protected void loadFileDBIgnore() throws ExceptionDBGit { loadFileDBIgnore(true); }} + : DBGitIgnore.getInstance(); + dbObjs.clear(); Map tbls = new HashMap(); @@ -262,7 +263,7 @@ public IMapMetaObject loadDBMetaData(boolean toIgnore) throws ExceptionDBGit { } public IMapMetaObject loadDBMetaData() throws ExceptionDBGit { - return loadDBMetaData(true); + return loadDBMetaData(false); } @@ -273,7 +274,7 @@ public IMapMetaObject loadFileMetaData() throws ExceptionDBGit { public IMapMetaObject loadFileMetaDataForce() throws ExceptionDBGit { return loadFileMetaData(true); } - + /** * Load meta data from git files * @return @@ -294,20 +295,14 @@ public IMapMetaObject loadFileMetaData(boolean force) throws ExceptionDBGit { if (force) { IMetaObject obj = loadMetaFile(filename); - if (obj != null) + if (obj != null) { objs.put(obj); + } -// ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("errors", "meta", "ok")); } else { try { - Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); IMetaObject obj = loadMetaFile(filename); - Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); - Long diff = timestampAfter.getTime() - timestampBefore.getTime(); - -// ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("errors", "meta", "okTime").withParams(diff.toString())); - if (obj != null) { objs.put(obj); } @@ -318,9 +313,7 @@ public IMapMetaObject loadFileMetaData(boolean force) throws ExceptionDBGit { ConsoleWriter.detailsPrintLn(e.getMessage()); IMetaObject obj = MetaObjectFactory.createMetaObject(filename); - - if (obj != null) - objs.put(obj); + objs.put(obj); } } } @@ -334,12 +327,16 @@ public IMapMetaObject loadFileMetaData(boolean force) throws ExceptionDBGit { throw new ExceptionDBGit(e); } } - + public IMetaObject loadMetaFile(String metaName) throws ExceptionDBGit { + return loadMetaFile(metaName, true); + } + + public IMetaObject loadMetaFile(String metaName, boolean forceLoad) throws ExceptionDBGit { AdapterFactory.createAdapter(); - if (fileObjs.containsKey(metaName)) - return fileObjs.get(metaName); - try { + if (!forceLoad && fileObjs.containsKey(metaName)) return fileObjs.get(metaName); + try + { IMetaObject obj = MetaObjectFactory.createMetaObject(metaName); obj = obj.loadFromFile(); if (obj != null) { From ccead7c04bef953f4aeff8b93ee9ee6857a2a168 Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 22:15:01 +0300 Subject: [PATCH 26/68] Fix DBBackupAdapter.backupDatabase to force reload db objects --- .../dbgit/adapters/DBBackupAdapter.java | 2 +- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 21 +++++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java index 2d1de7d..185fb0c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java @@ -71,7 +71,7 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { dbGitIndex = DBGitIndex.getInctance(); StatementLogging stLog = new StatementLogging(adapter.getConnection(), adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - IMapMetaObject dbObjs = GitMetaDataManager.getInstance().loadDBMetaData(); + IMapMetaObject dbObjs = GitMetaDataManager.getInstance().loadDBMetaData(true); IMapMetaObject dbToBackup = new TreeMapMetaObject(dbObjs.values().stream() .filter( x-> updateObjs.containsKey(x.getName()) ) diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index 646e3b6..3b14c11 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -44,6 +44,19 @@ private DBGit() throws ExceptionDBGit { } } + private DBGit(String url) throws ExceptionDBGit { + try { + FileRepositoryBuilder builder = new FileRepositoryBuilder(); + repository = builder + .setGitDir(new File(url)) + .build(); + + git = new Git(repository); + } catch (Exception e) { + throw new ExceptionDBGit(e); + } + } + public static DBGit getInstance() throws ExceptionDBGit { if (dbGit == null) { FileRepositoryBuilder builder = new FileRepositoryBuilder(); @@ -56,6 +69,14 @@ public static DBGit getInstance() throws ExceptionDBGit { } return dbGit; } + public static DBGit initUrlInstance(String gitDirUrl) throws ExceptionDBGit { + if (dbGit != null) { + throw new ExceptionDBGit("Already initialized"); + } + + dbGit = new DBGit(gitDirUrl); + return dbGit; + } public static boolean checkIfRepositoryExists() throws ExceptionDBGit { if (dbGit == null) { From 375849ae4a806c21ca90e668ecb483a00b2d143a Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 23:05:34 +0300 Subject: [PATCH 27/68] Introduction of DBGitTest - Tests are made in integration manner and uses test\resources\repo directory to init DBGit repository into - Tests are oriented in Postgres DBMS and uses -pgTestDbUrl -pgTestDbUser -pgTestDbPass params from cmdline, but can be easily tweaked to use other DBMSs by changin parameters and specifying needed DBGit repository url with target DBMS - Uses JUnit 5 (junit-jupiter) to use improved annotations and 'tags' functionality, better commandline args support --- pom.xml | 42 +- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 2 +- .../java/ru/fusionsoft/dbgit/DBGitTest.java | 408 ++++++++++++++++++ src/test/resources/repo | 1 + 4 files changed, 444 insertions(+), 9 deletions(-) create mode 100644 src/test/java/ru/fusionsoft/dbgit/DBGitTest.java create mode 160000 src/test/resources/repo diff --git a/pom.xml b/pom.xml index 5d3197f..797e680 100644 --- a/pom.xml +++ b/pom.xml @@ -8,6 +8,22 @@ jar + + + org.apache.maven.plugins + maven-surefire-plugin + 3.0.0-M5 + + + + + + + + maven-failsafe-plugin + 3.0.0-M5 + + org.apache.maven.plugins @@ -117,13 +133,6 @@ - - - junit - junit - 4.12 - test - @@ -195,6 +204,23 @@ 1.4 + + + + + + + + org.junit.jupiter + junit-jupiter-engine + 5.6.2 + + + + org.junit.jupiter + junit-jupiter-api + 5.6.2 + @@ -235,7 +261,7 @@ 18.3.0.0 - + com.microsoft.sqlserver mssql-jdbc 7.0.0.jre8 diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index 3b14c11..0a5ab05 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -269,7 +269,7 @@ public void gitCheckout(String branch, String commit, boolean isNewBranch) throw result = checkout.call(); - ConsoleWriter.printlnGreen(result != null ? result.getName() : commit); +// ConsoleWriter.printlnGreen(result != null ? result.getName() : commit); } else { MaskFilter maskAdd = new MaskFilter(branch); diff --git a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java new file mode 100644 index 0000000..7d27d5f --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java @@ -0,0 +1,408 @@ +package ru.fusionsoft.dbgit; + +import com.google.common.collect.MapDifference; +import com.google.common.collect.Maps; +import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.Option; +import org.apache.commons.io.FileUtils; +import org.eclipse.jgit.api.Git; +import org.eclipse.jgit.api.errors.GitAPIException; +import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; +import org.eclipse.jgit.internal.storage.dfs.InMemoryRepository; +import org.eclipse.jgit.internal.storage.file.FileRepository; +import org.eclipse.jgit.lib.Repository; +import org.eclipse.jgit.revwalk.RevCommit; +import org.eclipse.jgit.transport.RefSpec; +import org.junit.jupiter.api.*; +import static org.junit.jupiter.api.Assertions.*; + +import org.postgresql.jdbc.PgConnection; +import ru.fusionsoft.dbgit.command.*; +import ru.fusionsoft.dbgit.core.*; +import ru.fusionsoft.dbgit.meta.IMapMetaObject; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.postgres.DBAdapterPostgres; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Path; +import java.sql.Connection; +import java.sql.DriverManager; +import java.text.MessageFormat; +import java.util.*; + + +// 1. We use test repository in 'resources' folder +// 2. We use test database created in selected server +// 3. We have various test scenarios to test COMMANDS and their COMBINATIONS +// + CmdAdd - check add files from DATABASE to REPO +//CmdRm - check delete files, DBINDEX operations, CmdRestore interchange, +//CmdDump - check the same as CmdAdd +//CmdBackup - check add backup files to test DATABASE +// +- CmdRestore - lots of scenarios on 1. restore schema 2. delete objs 3. modify schema 4. modify data 5. backups +// + CmdCheckout +//CmdStatus CmdValid +// + CmdLink CmdInit CmdConfig +//CmdCommit CmdPush CmdPull CmdFetch +//CmdRemote CmdMerge CmdReset +//CmdSynonymSchema CmdHelp CmdClone +// + + +@Tag("pgTest") +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +public class DBGitTest { + + static String repoUrl = "https://github.com/rocket-3/dbgit-test.git"; + static String repoBranch = "master"; + static String pgTestDbUrl = "jdbc:postgresql://localhost/"; + static String pgTestDbUser = "postgres"; + static String pgTestDbPass = "pass"; + static String pgTestDbCatalog = "testDatabasegit"; + static List commitNumbers = new ArrayList<>(); + //Now commit numbers are loaded automaticvally + /*Arrays.asList( + "88673845e9891228d2ebb7ad3bdebb534ce8efbe", + "b1fecd7ebcf33a61fa7b962cb5e92ae6cdb8db64", + "831054e4eac9a1f0d1797b6f65ebd64e7d81f74f", + "d2b40808dd6df2d51d80bddbdcdfdabef7394373", + "4f3953d44743a539321d024871182eef8f1cd7f9" + );*/ + static Path resourcesRepoDirectory = new File( "src/test/resources/repo").toPath(); + static Path resourcesRepoGitDirectory = resourcesRepoDirectory.resolve(".git"); + + static Properties pgTestDbProps = new Properties(); + static DBConnection pgTestDbConnection = null; + + + + @BeforeAll + public static void setUp() throws Exception { + DBGit.initUrlInstance(resourcesRepoGitDirectory.toString()); + + if(commitNumbers.isEmpty()){ + loadCommitNumbersFromRepo(); + } + + configureTestDb(); + } + + private static void loadCommitNumbersFromRepo() throws GitAPIException, IOException { + DfsRepositoryDescription repoDesc = new DfsRepositoryDescription(); + InMemoryRepository repo = new InMemoryRepository(repoDesc); + Git git = new Git(repo); + git.fetch() + .setRemote(repoUrl) + .setRefSpecs(new RefSpec("+refs/heads/"+repoBranch+":refs/heads/"+repoBranch)) + .call(); + + String treeName = "refs/heads/"+repoBranch; // tag or branch + for (RevCommit commit : git.log().add(repo.resolve(treeName)).call()) { + commitNumbers.add(commit.getName()); + } + } + + @BeforeEach + public void init() throws Exception { + restoreDbLinkIfNeeded(); + } + + @Test + @Order(1) + public void CmdClone() throws Exception { + FileUtils.cleanDirectory(resourcesRepoDirectory.toFile()); + dbgitClone(repoUrl, String.valueOf(resourcesRepoDirectory)); + + + File gitFile = resourcesRepoDirectory.resolve(".git").toFile(); + File dbgitFile = resourcesRepoDirectory.resolve(".dbgit").toFile(); + File[] dbgitFiles = dbgitFile.listFiles(); + + assertTrue(gitFile.exists(), "'.git folder exists'"); + assertTrue(dbgitFile.exists(), "'.dbgit folder exists'"); + assertTrue(dbgitFiles != null && dbgitFiles.length > 0, "'.dbgit folder is not empty'"); + + ConsoleWriter.printlnGreen(MessageFormat.format("Number of files in .dbgit {0}", dbgitFiles.length )); + Arrays.asList(dbgitFiles).forEach(x->ConsoleWriter.printlnRed(x.getPath())); + + } + + @Test + @Order(2) + public void CmdLink() throws Exception { + CmdLink cmd = new CmdLink(); + String notValidUrl = "jdbc:postgresql://4.4.4.4/"; + File dblinkFile = resourcesRepoDirectory.resolve(".dbgit").resolve(".dblink").toFile(); + dblinkFile.delete(); + +// DriverManager.setLoginTimeout(3); +// cmd.execute(getLinkCommandLine(notValidUrl, null, null)); +// assertFalse(dblinkFile.exists(), "'.dblink file not created on non-valid url'"); + + cmd.execute(getLinkCommandLine(pgTestDbUrl, pgTestDbUser, pgTestDbPass)); + assertTrue(dblinkFile.exists()); + + } + + @Test + @Order(3) + public void CmdCheckout() throws Exception { + boolean isNoDb = true; + boolean isRestore = false; + boolean isCreateBranch = false; + boolean isUpgrade = false; + + GitMetaDataManager.getInstance().loadDBMetaData(); + for(String commitNumber : commitNumbers){ + dbgitCheckout(repoBranch, commitNumber, isNoDb, isRestore, isCreateBranch, isUpgrade); + } + + assertDoesNotThrow( () ->dbgitCheckout(repoBranch, commitNumbers.get(0), false, true, isCreateBranch, isUpgrade) ); + } + + @Test + @Order(4) + public void CmdReset() throws Exception { + + File dblinkFile = resourcesRepoDirectory.resolve(".dbgit").resolve(".dblink").toFile(); + List modes = Arrays.asList("soft", "mixed", "hard", "merge", "keep"); + + dblinkFile.delete(); + assertFalse(dblinkFile.exists()); + + dbgitReset("hard"); + assertTrue(dblinkFile.exists()); + + + } + + @Test + @Order(5) + public void CmdRestore() throws Exception { + boolean isRestore = false; + boolean isToMakeBackup = true; + boolean isNoDb = true; + boolean isCreateBranch = false; + boolean isUpgrade = false; + + + dbgitReset("hard"); + setToMakeBackup(isToMakeBackup); + + for(String commitNumber : commitNumbers){ + String scriptPath = resourcesRepoDirectory.resolve("restore#"+commitNumber+".sql").toAbsolutePath().toString(); + File scriptFile = new File(scriptPath); + + scriptFile.delete(); + ConsoleWriter.printlnGreen("\nDoing checkout:"); + + dbgitCheckout(repoBranch, commitNumber, isNoDb, isRestore, isCreateBranch, isUpgrade, scriptPath); + dbgitCheckoutLs(); + +// ConsoleWriter.printlnGreen(MessageFormat.format("++ checkout: {0} symbols, path:\n{1}", +// scriptFile.exists() ? FileUtils.readFileToString(scriptFile).length() : 0, +// scriptPath +// )); + + scriptFile.delete(); + dbgitRestore(true, true, scriptPath); + + ConsoleWriter.printlnGreen(MessageFormat.format("Done restore, script: \n{1} ({0} syms.)", + scriptFile.exists() ? FileUtils.readFileToString(scriptFile).length() : 0, + scriptPath + )); + } + } + + @Test + @Order(6) + public void CmdAdd() throws Exception { + CmdAdd cmd = new CmdAdd(); + // checkout to last commit - restore files and database + // checkout 1st commit - restore files, index + // call cmdAdd + // ensure files added (what files?) - from last commit db state + + String firstCommit = commitNumbers.get(0); + String lastCommit = commitNumbers.get(commitNumbers.size()-1); + + dbgitCheckout(repoBranch, lastCommit, false, true, false, false); + IMapMetaObject fileImos = GitMetaDataManager.getInstance().loadFileMetaData(); + IMapMetaObject databaseImos = GitMetaDataManager.getInstance().loadDBMetaData(); + MapDifference diffs = Maps.difference(fileImos, databaseImos); + + ConsoleWriter.detailsPrintLn("Diffs: "); + diffs.entriesDiffering().forEach( (key, value) -> { + ConsoleWriter.detailsPrintLn(MessageFormat.format("{0} -> ({1}, {2})", + key, value.leftValue(), value.rightValue())); + }); + + + } + + + private static void dbgitClone(String urlFrom, String dirTo) throws Exception { + CmdClone cmdClone = new CmdClone(); + Option directoryOption = Option.builder().longOpt("directory").hasArg(true).numberOfArgs(1).build(); + directoryOption.getValuesList().add(dirTo); + CommandLine cmdLineClone = new CommandLine.Builder().addArg(urlFrom).addOption(directoryOption).build(); + cmdClone.execute(cmdLineClone); + } + + private static void dbgitReset(String mode) throws Exception { + CmdReset cmd = new CmdReset(); + Option optionMode = new Option(mode , false, mode); + CommandLine.Builder builder = new CommandLine.Builder(); + cmd.execute(builder.addOption(optionMode).build()); + } + + private static void dbgitCheckout(String branchName, String commitNumber, boolean isNoDb, boolean isRestore, boolean isCreateBranch, boolean isUpgrade) throws Exception { + dbgitCheckout(branchName, commitNumber, isNoDb, isRestore, isCreateBranch, isUpgrade, null); + } + private static void dbgitCheckout(String branchName, String commitNumber, boolean isNoDb, boolean isRestore, boolean isCreateBranch, boolean isUpgrade, String scriptPath + ) throws Exception { + CmdCheckout cmd = new CmdCheckout(); + CommandLine.Builder builder = new CommandLine.Builder(); + String actualBranchName = branchName == null ? "master" : branchName; + + Option nodbOption = Option.builder("nodb").hasArg(false).build(); + Option restoreOption = Option.builder("r").hasArg(false).build(); + Option newBranchOption = Option.builder("b").hasArg(false).build(); + Option upgradeOption = Option.builder("u").hasArg(false).build(); + Option scriptOption = Option.builder("s").hasArg(true).build(); + + builder.addArg(actualBranchName); + if(commitNumber != null){ + builder.addArg(commitNumber); + } + if(isNoDb){ + builder.addOption(nodbOption); + } + if(isRestore){ + builder.addOption(restoreOption); + } + if(isCreateBranch){ + builder.addOption(newBranchOption); + } + if(isUpgrade){ + builder.addOption(upgradeOption); + } + if(scriptPath != null){ + scriptOption.getValuesList().add(scriptPath); + builder.addOption(scriptOption); + } + + cmd.execute(builder.build()); + } + + private static void dbgitCheckoutLs() throws Exception { + CmdCheckout cmd = new CmdCheckout(); + CommandLine.Builder builder = new CommandLine.Builder(); + + Option lsOption = Option.builder("ls").hasArg(false).build(); + builder.addOption(lsOption); + + cmd.execute(builder.build()); + } + + private static void dbgitRestore(boolean isRestore, boolean isToMakeBackup, String scriptPath) throws Exception { + CmdRestore cmd = new CmdRestore(); + CommandLine.Builder builder = new CommandLine.Builder(); + + + if(isRestore){ + Option restoreOption = Option.builder("r").hasArg(false).build(); + builder.addOption(restoreOption); + } + if(scriptPath != null){ + Option scriptOption = Option.builder("s").hasArg(true).numberOfArgs(1).build(); + scriptOption.getValuesList().add(scriptPath); + builder.addOption(scriptOption); + } + setToMakeBackup(isToMakeBackup); + + cmd.execute(builder.build()); + } + + private static void configureTestDb() throws Exception { + String propDbUrl = System.getProperty("pgTestDbUrl"); + String propDbUser = System.getProperty("pgTestDbUser"); + String propDbPass = System.getProperty("pgTestDbPass"); + if(propDbUrl != null){ + ConsoleWriter.printlnGreen(MessageFormat.format("Overriding DBConnection url from props: {0}", pgTestDbUrl)); + pgTestDbUrl = propDbUrl; + pgTestDbUser = propDbUser; + pgTestDbPass = propDbPass; + } else { + ConsoleWriter.printlnGreen(MessageFormat.format("Using defaults DBConnection url: {0}", pgTestDbUrl)); + } + if(pgTestDbUser != null && pgTestDbPass != null){ + pgTestDbProps.put("user", pgTestDbUser); + pgTestDbProps.put("password", pgTestDbPass); + } + try (Connection conn = DriverManager.getConnection(pgTestDbUrl, pgTestDbProps)) { + if (!conn.getCatalog().isEmpty()) { + throw new Exception("Catalog must not be specified to create test database."); + } + + conn.createStatement().execute(MessageFormat.format( + "DROP DATABASE IF EXISTS {0}; " + + "CREATE DATABASE {0} ENCODING = 'UTF8'", + DBAdapterPostgres.escapeNameIfNeeded(pgTestDbCatalog) + )); + pgTestDbUrl = MessageFormat.format( + "{0}{1}{2}", + pgTestDbUrl, + !pgTestDbUrl.endsWith("/") ? "/" : "", + pgTestDbCatalog + ); + } + + DBConnection.createFileDBLink(pgTestDbUrl, pgTestDbProps, false); + pgTestDbConnection = DBConnection.getInstance(true); + + } + + private static void restoreDbLinkIfNeeded() throws Exception { + String urlWas = DBConnection.loadFileDBLink(new Properties()); + if(pgTestDbConnection == null || !urlWas.equals(pgTestDbUrl)){ + new CmdLink().execute(getLinkCommandLine(pgTestDbUrl, pgTestDbUser, pgTestDbPass)); + pgTestDbConnection = DBConnection.getInstance(); + + ConsoleWriter.printlnGreen(MessageFormat.format( + "+ .dblink restored, \nwas: {0}, \nnow: {1}" + , urlWas, ((PgConnection) pgTestDbConnection.getConnect()).getURL() + )); + } + assertEquals(((PgConnection) pgTestDbConnection.getConnect()).getURL(), pgTestDbUrl); + } + + private static void setToMakeBackup(boolean isToMakeBackup) throws Exception { + String sectionName = "core"; + String parameterName = "TO_MAKE_BACKUP"; + ConsoleWriter.detailsPrintlnRed(MessageFormat.format("+ TO_MAKE_BACKUP was: {0}", + String.valueOf(DBGitConfig.getInstance().getBoolean(sectionName, parameterName, false)) + )); + DBGitConfig.getInstance().setValue("TO_MAKE_BACKUP", isToMakeBackup ? "true" : "false"); + + ConsoleWriter.detailsPrintlnRed(MessageFormat.format("+ TO_MAKE_BACKUP (set, now)): {0}, {1}", + String.valueOf(isToMakeBackup), + String.valueOf(DBGitConfig.getInstance().getBoolean(sectionName, parameterName, false)) + )); + } + + private static CommandLine getLinkCommandLine(String url, String user, String pass){ + CommandLine.Builder builder = new CommandLine.Builder().addArg(url); + if(user != null) { + builder.addArg("user=" + user); + + } + if(pass != null) { + builder.addArg("password=" + pass); + } + return builder.build(); + } + + +} diff --git a/src/test/resources/repo b/src/test/resources/repo new file mode 160000 index 0000000..4f3953d --- /dev/null +++ b/src/test/resources/repo @@ -0,0 +1 @@ +Subproject commit 4f3953d44743a539321d024871182eef8f1cd7f9 From 9b2c02b269724eaaafd4dd49ffb7a14d2e716cc0 Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 23:31:14 +0300 Subject: [PATCH 28/68] DBRestoreTablePostgres mass refactor and fix multiple errors found from tests, prepare to use -2 step of restore table (drop index and constraints) DBAdapterPostgres fix getTable(s) methods sql scripts DBAdapterPostgres.getTableFields field type universal override from TEXT->STRING to TEXT->STRING_NATIVE to make this conversion distinct --- .../fusionsoft/dbgit/adapters/DBAdapter.java | 1 + .../fusionsoft/dbgit/core/db/FieldType.java | 1 + .../dbgit/postgres/DBAdapterPostgres.java | 40 +- .../postgres/DBRestoreTablePostgres.java | 769 +++++++++--------- 4 files changed, 426 insertions(+), 385 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 2631944..b693fd9 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -277,6 +277,7 @@ public void registryMappingTypes() { FactoryCellData.regMappingTypes(FieldType.NATIVE, StringData.class); FactoryCellData.regMappingTypes(FieldType.NUMBER, LongData.class); FactoryCellData.regMappingTypes(FieldType.STRING, StringData.class); + FactoryCellData.regMappingTypes(FieldType.STRING_NATIVE, StringData.class); FactoryCellData.regMappingTypes(FieldType.TEXT, TextFileData.class); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/db/FieldType.java b/src/main/java/ru/fusionsoft/dbgit/core/db/FieldType.java index 88bebb6..30fe0c6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/db/FieldType.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/db/FieldType.java @@ -9,6 +9,7 @@ public enum FieldType { NATIVE("native"), NUMBER("number"), STRING("string"), + STRING_NATIVE("string native"), TEXT("text"); private String typeName; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index cf9a874..a2349b4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -201,27 +201,27 @@ public Map getTables(String schema) { try { String query = "select \n" + - " tablename as table_name,\n" + - " tableowner as owner,\n" + + " tablename AS table_name,\n" + + " tableowner AS owner,\n" + " tablespace,hasindexes,hasrules,hastriggers, \n" + - " obj_description(to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid) table_comment, ( \n" + - " select array_agg(distinct n2.nspname || '/' || c2.relname || '.tbl') as dependencies\n" + + " obj_description(to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid) AS table_comment, " + + " ( " + + " SELECT array_agg( distinct n2.nspname || '/' || c2.relname || '.tbl' ) AS dependencies\n" + " FROM pg_catalog.pg_constraint c \n" + " JOIN ONLY pg_catalog.pg_class c1 ON c1.oid = c.conrelid\n" + " JOIN ONLY pg_catalog.pg_class c2 ON c2.oid = c.confrelid\n" + " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + " WHERE c.conrelid = to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid\n" + " and c1.relkind = 'r' AND c.contype = 'f'\n" + - " ), \n" + - "(SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) oid, \n" + - " pg_get_partkeydef((SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema))) partkeydef, \n" + - " parent.relname parent, \n" + - " pg_get_expr(child.relpartbound, child.oid) \n" + - "from pg_tables \n" + - "left outer join pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) = pg_inherits.inhrelid \n" + - "left outer JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + - "left outer JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + - + " ) AS dependencies, \n" + + " pg_get_partkeydef((SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"'))) " + + " AS partkeydef, \n" + + " parent.relname AS parent, \n" + + " pg_get_expr(child.relpartbound, child.oid) AS pg_get_expr \n" + + "from pg_tables \n" + + "left outer join pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) = pg_inherits.inhrelid \n" + + "left outer JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + + "left outer JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + "where upper(schemaname) = upper(:schema)"; Connection connect = getConnection(); @@ -267,11 +267,11 @@ public DBTable getTable(String schema, String name) { " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + " WHERE c.conrelid = to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid\n" + " and c1.relkind = 'r' AND c.contype = 'f'\n" + - " ), \n" + - "(SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"')) oid, \n" + - " pg_get_partkeydef((SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"'))) partkeydef, \n" + - " parent.relname parent, \n" + - " pg_get_expr(child.relpartbound, child.oid) \n" + + " ) AS dependencies, \n" + + " pg_get_partkeydef((SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"'))) " + + " AS partkeydef, \n" + + " parent.relname AS parent, \n" + + " pg_get_expr(child.relpartbound, child.oid) AS pg_get_expr\n" + "from pg_tables \n" + "left outer join pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"')) = pg_inherits.inhrelid \n" + "left outer JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + @@ -359,7 +359,7 @@ public Map getTableFields(String schema, String nameTable field.setIsNullable( !typeSQL.toLowerCase().contains("not null")); field.setTypeUniversal(FieldType.fromString(rs.getString("tp"))); //TODO more verbose type override - if(field.getTypeUniversal() == FieldType.TEXT) field.setTypeUniversal(FieldType.STRING); + if(field.getTypeUniversal() == FieldType.TEXT) field.setTypeUniversal(FieldType.STRING_NATIVE); field.setFixed(false); field.setLength(rs.getInt("character_maximum_length")); field.setPrecision(rs.getInt("numeric_precision")); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index f78adbe..b838623 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -7,11 +7,15 @@ import com.google.common.collect.Sets; import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.core.GitMetaDataManager; import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.dbobjects.*; +import ru.fusionsoft.dbgit.meta.DBGitMetaType; import ru.fusionsoft.dbgit.meta.IMetaObject; import ru.fusionsoft.dbgit.meta.MetaTable; +import ru.fusionsoft.dbgit.meta.NameMeta; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.StringProperties; @@ -43,11 +47,37 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { return false; } + if(Integer.valueOf(step).equals(-2)) { + removeTableConstraintsPostgres(obj); + removeTableIndexesPostgres(obj); + return false; + } + return true; } + public void removeMetaObject(IMetaObject obj) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - public void restoreTablePostgres(IMetaObject obj) throws Exception - { + try { + MetaTable tblMeta = (MetaTable)obj; + DBTable tbl = tblMeta.getTable(); + if (tbl == null) return; + + String schema = getPhisicalSchema(tbl.getSchema()); + + freeTableSequences(tbl, connect, st); + st.execute("DROP TABLE "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(tbl.getName())); + } catch (Exception e) { + ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); + } finally { + st.close(); + } + } + + public void restoreTablePostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -58,191 +88,29 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception String schema = DBAdapterPostgres.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase())); String tblName = DBAdapterPostgres.escapeNameIfNeeded(restoreTable.getTable().getName()); + String tblSam = DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(tblName); ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTable").withParams(schema+"."+tblName), 1); //find existing table and set tablespace or create if (existingTable.loadFromDB()){ - StringProperties exTablespace = existingTable.getTable().getOptions().get("tablespace"); - StringProperties restoreTablespace = restoreTable.getTable().getOptions().get("tablespace"); - if(restoreTablespace != null && - ( exTablespace == null || !exTablespace.getData().equals(restoreTablespace.getData()) ) ){ - //TODO For now in postgres context tablespace is always missing! - String alterTableDdl = MessageFormat.format( - "alter table {0}.{1} set tablespace {2};\n" - ,schema - ,tblName - ,restoreTable.getTable().getOptions().get("tablespace").getData() - ); - st.execute(alterTableDdl); - } - - StringProperties exOwner= existingTable.getTable().getOptions().get("owner"); - StringProperties restoreOwner = restoreTable.getTable().getOptions().get("owner"); - if(restoreOwner != null && ( exOwner == null || !exOwner.getData().equals(restoreOwner.getData()) ) ){ - String alterTableDdl = MessageFormat.format( - "alter table {0}.{1} owner to {2};\n" - ,schema - ,tblName - ,restoreTable.getTable().getOptions().get("owner").getData() - ); - st.execute(alterTableDdl); - } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - } else { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "createTable"), 2); - - Collection fields = restoreTable.getFields().values(); - StringBuilder columnsBld = new StringBuilder(); - - for (DBTableField field : fields) { - String fieldStr = field.getName() + " " + field.getTypeSQL().replace("NOT NULL" , ""); - columnsBld.append(fieldStr).append(", "); - } - String columns = columnsBld.substring(0, columnsBld.length() - 2); - - String createTableDdl = MessageFormat.format( - "create table {0}.{1}({4}) {2};\n alter table {0}.{1} owner to {3}" - ,schema - ,tblName - ,restoreTable.getTable().getOptions().getChildren().containsKey("tablespace") - ? "tablespace " + restoreTable.getTable().getOptions().get("tablespace").getData() - : "" - ,restoreTable.getTable().getOptions().getChildren().containsKey("owner") - ? restoreTable.getTable().getOptions().get("owner").getData() - : "postgres" - , columns - ); - - if (restoreTable.getTable().getOptions().getChildren().containsKey("partkeydef")) { - createTableDdl = createTableDdl.replace(" ) ", - ") PARTITION BY " + - restoreTable.getTable().getOptions().getChildren().get("partkeydef") - + " "); - } - - st.execute(createTableDdl); + restoreTableTablespace(st, restoreTable, existingTable); + restoreTableOwner(st, restoreTable, existingTable); ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - } - //restore comment - if (restoreTable.getTable().getComment() != null && restoreTable.getTable().getComment().length() > 0){ - st.execute(MessageFormat.format( - "COMMENT ON TABLE {0}.{1} IS ''{2}''" - ,schema - ,tblName - ,restoreTable.getTable().getComment() - )); - } - - //restore tabl fields -// Map currentFileds = adapter.getTableFields(schema.toLowerCase(), restoreTable.getTable().getName().toLowerCase()); - MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),existingTable.getFields()); - String tblSam = DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(tblName); - - if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addColumns"), 0); - - Comparator comparator = Comparator.comparing(DBTableField::getOrder); - - List values = new ArrayList<>(diffTableFields.entriesOnlyOnLeft().values()); - values.sort(comparator); - - for(DBTableField tblField : values) { - String fieldName = DBAdapterPostgres.escapeNameIfNeeded(tblField.getName()); -/* - st.execute( - "alter table "+ tblSam +" add column " - + fieldName + " " - + tblField.getTypeSQL().replace("NOT NULL", "") - ); -*/ - if (tblField.getDescription() != null && tblField.getDescription().length() > 0) - st.execute( - "COMMENT ON COLUMN " + tblSam + "." - + fieldName - + " IS '" + tblField.getDescription() + "'" - ); - - if (!tblField.getIsNullable()) { - st.execute( - "alter table " + tblSam - + " alter column " + fieldName - + " set not null" - ); - } - - if (tblField.getDefaultValue() != null && tblField.getDefaultValue().length() > 0) { - st.execute("alter table " + tblSam + " alter column " + fieldName - + " SET DEFAULT " + tblField.getDefaultValue()); - } + } else { - } + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "createTable"), 2); + createTable(st, restoreTable); ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - } - - if (restoreTable.getTable().getOptions().getChildren().containsKey("parent")) { - String attachPart = " ALTER TABLE " + - schema + "." + restoreTable.getTable().getOptions().getChildren().get("parent") + - " ATTACH PARTITION " + - schema + "." + tblName + " " + - restoreTable.getTable().getOptions().getChildren().get("pg_get_expr"); - st.execute(attachPart); - } - if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 2); - for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { - st.execute("alter table "+ tblSam +" drop column "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.getName())); - } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); } - if(!diffTableFields.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "modifyColumns"), 2); - for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { - if(!tblField.leftValue().getName().equals(tblField.rightValue().getName())) { - st.execute( - "alter table " - + tblSam - +" rename column "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.rightValue().getName()) - +" to "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) - ); - } - - if (restoreTable.getTable().getComment() != null && restoreTable.getTable().getComment().length() > 0) - st.execute("COMMENT ON COLUMN " + tblSam + "." + DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + " IS '" + tblField.leftValue().getDescription() + "'"); - - if( !tblField.leftValue().getTypeSQL().equals(tblField.rightValue().getTypeSQL()) - && tblField.rightValue().getTypeUniversal() != FieldType.BOOLEAN) { - st.execute( - "alter table " - + tblSam - +" alter column "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) - +" type "+ tblField.leftValue().getTypeSQL().replace("NOT NULL", "") - ); - if (!tblField.leftValue().getIsNullable()) { - st.execute( - "alter table " + tblSam - + " alter column " + DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) - + " set not null" - ); - } - - } - if ( - tblField.leftValue().getDefaultValue() != null - && tblField.leftValue().getDefaultValue().length() > 0 - && !tblField.leftValue().getDefaultValue().equals(tblField.rightValue().getDefaultValue()) - ) { - st.execute("alter table " + tblSam + " alter column " + DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) - + " SET DEFAULT " + tblField.leftValue().getDefaultValue()); - } - } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - } + restoreTableFields(restoreTable, existingTable, st); + restoreTableComment(restoreTable, existingTable, st); + restoreTablePartition(restoreTable, st); } else { @@ -255,107 +123,6 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception st.close(); } } - public void restoreTableFieldsPostgres(IMetaObject obj) throws Exception - { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { - if (obj instanceof MetaTable) { - MetaTable restoreTable = (MetaTable)obj; - String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); - String tblName = schema+"."+restoreTable.getTable().getName(); - Map tables = adapter.getTables(schema); - boolean exist = false; - if(!(tables == null || tables.isEmpty() )) { - for(DBTable table:tables.values()) { - if(restoreTable.getTable().getName().equals(table.getName())){ - exist = true; - Map currentFileds = adapter.getTableFields(schema, restoreTable.getTable().getName()); - MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),currentFileds); - - if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ - for(DBTableField tblField:diffTableFields.entriesOnlyOnLeft().values()) { - st.execute("alter table "+ tblName +" add column " + tblField.getName() + " " + tblField.getTypeSQL()); - - if (tblField.getDescription() != null && tblField.getDescription().length() > 0) - st.execute("COMMENT ON COLUMN " + tblName + "." + ((adapter.isReservedWord(tblField.getName()) || tblField.getNameExactly()) ? "\"" + tblField.getName() + "\" " : tblField.getName()) + " IS '" + tblField.getDescription() + "'"); - - if (!tblField.getIsNullable()) { - st.execute("alter table " + tblName + " alter column " + (adapter.isReservedWord(tblField.getName()) ? "\"" + tblField.getName() + "\" " : tblField.getName()) + " set not null"); - } - - if (tblField.getDefaultValue() != null && tblField.getDefaultValue().length() > 0) { - st.execute("alter table " + tblName + " alter column " + (adapter.isReservedWord(tblField.getName()) ? "\"" + tblField.getName() + "\" " : tblField.getName()) - + " SET DEFAULT " + tblField.getDefaultValue()); - } - } - } - - if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { - for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { - st.execute("alter table "+ tblName +" drop column IF EXISTS "+ tblField.getName()); - } - } - - if(!diffTableFields.entriesDiffering().isEmpty()) { - for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { - if(!tblField.leftValue().getName().equals(tblField.rightValue().getName())) { - st.execute("alter table "+ tblName +" rename column "+ tblField.rightValue().getName() +" to "+ tblField.leftValue().getName()); - } - - if(!tblField.leftValue().getTypeSQL().equals(tblField.rightValue().getTypeSQL())) { - st.execute("alter table "+ tblName +" alter column "+ tblField.leftValue().getName() +" type "+ tblField.leftValue().getTypeSQL()); - } - } - } - } - } - } - if(!exist){ - for(DBTableField tblField:restoreTable.getFields().values()) { - st.execute("alter table "+ tblName +" add column " + tblField.getName() + " " + tblField.getTypeSQL()); - - if (tblField.getDescription() != null && tblField.getDescription().length() > 0) - st.execute("COMMENT ON COLUMN " + tblName + "." + ((adapter.isReservedWord(tblField.getName()) || tblField.getNameExactly()) ? "\"" + tblField.getName() + "\" " : tblField.getName()) + " IS '" + tblField.getDescription() + "'"); - - if (!tblField.getIsNullable()) { - st.execute("alter table " + tblName + " alter column " + (adapter.isReservedWord(tblField.getName()) ? "\"" + tblField.getName() + "\" " : tblField.getName()) + " set not null"); - } - - if (tblField.getDefaultValue() != null && tblField.getDefaultValue().length() > 0) { - st.execute("alter table " + tblName + " alter column " + (adapter.isReservedWord(tblField.getName()) ? "\"" + tblField.getName() + "\" " : tblField.getName()) - + " SET DEFAULT " + tblField.getDefaultValue()); - } - - } - } - - ResultSet rs = st.executeQuery("SELECT COUNT(*) as constraintscount FROM pg_catalog.pg_constraint r WHERE r.conrelid = '"+tblName+"'::regclass"); - rs.next(); - Integer constraintsCount = Integer.valueOf(rs.getString("constraintscount")); - if(constraintsCount.intValue()>0) { - removeTableConstraintsPostgres(obj); - } - // set primary key - for(DBConstraint tableconst: restoreTable.getConstraints().values()) { - if(tableconst.getConstraintType().equals("p") && !restoreTable.getTable().getOptions().getChildren().containsKey("parent")) { - st.execute("alter table "+ tblName +" add constraint "+ DBAdapterPostgres.escapeNameIfNeeded(tableconst.getName()) + " "+tableconst.getSql().replace(" " + tableconst.getSql() + ".", " " + schema + ".")); - break; - } - } - } - else - { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); @@ -373,16 +140,16 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { for(DBIndex ind:diffInd.entriesOnlyOnLeft().values()) { if(restoreTable.getConstraints().containsKey(ind.getName())) {continue;} st.execute(MessageFormat.format("{0} {1}" - ,ind.getSql().replace(" INDEX ", " INDEX IF NOT EXISTS ") - ,ind.getOptions().getChildren().containsKey("tablespace") ? " tablespace " + ind.getOptions().get("tablespace").getData() : "" + ,ind.getSql().replace(" INDEX ", " INDEX IF NOT EXISTS ") + ,ind.getOptions().getChildren().containsKey("tablespace") ? " tablespace " + ind.getOptions().get("tablespace").getData() : "" )); } for(DBIndex ind:diffInd.entriesOnlyOnRight().values()) { if(existingTable.getConstraints().containsKey(ind.getName())) continue; st.execute(MessageFormat.format("drop index if exists {0}.{1}" - , DBAdapterPostgres.escapeNameIfNeeded(schema) - , DBAdapterPostgres.escapeNameIfNeeded(ind.getName()) + , DBAdapterPostgres.escapeNameIfNeeded(schema) + , DBAdapterPostgres.escapeNameIfNeeded(ind.getName()) )); } @@ -391,18 +158,18 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { DBIndex existingIndex = ind.rightValue(); if(!restoreIndex.getSql().equalsIgnoreCase(existingIndex.getSql())) { st.execute(MessageFormat.format( - "DROP INDEX {0}.{1} CASCADE;\n" + "{2};\n", //TODO discuss CASCADE - DBAdapterPostgres.escapeNameIfNeeded(schema) - , DBAdapterPostgres.escapeNameIfNeeded(existingIndex.getName()) - , restoreIndex.getSql() //drop and re-create using full DDL from .getSql() + "DROP INDEX {0}.{1} CASCADE;\n" + "{2};\n", //TODO discuss CASCADE + DBAdapterPostgres.escapeNameIfNeeded(schema) + , DBAdapterPostgres.escapeNameIfNeeded(existingIndex.getName()) + , restoreIndex.getSql() //drop and re-create using full DDL from .getSql() )); st.execute(MessageFormat.format( - "alter index {0}.{1} set tablespace {2}" - ,DBAdapterPostgres.escapeNameIfNeeded(schema) - ,DBAdapterPostgres.escapeNameIfNeeded(restoreIndex.getName()) - ,restoreIndex.getOptions().getChildren().containsKey("tablespace") - ? restoreIndex.getOptions().get("tablespace").getData() - : "pg_default" + "alter index {0}.{1} set tablespace {2}" + ,DBAdapterPostgres.escapeNameIfNeeded(schema) + ,DBAdapterPostgres.escapeNameIfNeeded(restoreIndex.getName()) + ,restoreIndex.getOptions().getChildren().containsKey("tablespace") + ? restoreIndex.getOptions().get("tablespace").getData() + : "pg_default" )); } } @@ -441,19 +208,19 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { //drop unneeded for(DBConstraint constr : diff.entriesOnlyOnLeft().values()){ st.execute(MessageFormat.format( - "alter table {0}.{1} drop constraint {2};\n" - , DBAdapterPostgres.escapeNameIfNeeded(schema) - , DBAdapterPostgres.escapeNameIfNeeded(existingTable.getTable().getName()) - , DBAdapterPostgres.escapeNameIfNeeded(constr.getName()) + "alter table {0}.{1} drop constraint {2};\n" + , DBAdapterPostgres.escapeNameIfNeeded(schema) + , DBAdapterPostgres.escapeNameIfNeeded(existingTable.getTable().getName()) + , DBAdapterPostgres.escapeNameIfNeeded(constr.getName()) )); } // restore not existing - // not restore index if not exists and have the same named PK + // * not restore index if not exists and have the same named PK Set typesFirst = Sets.newHashSet("p", "u"); Comparator pksFirstComparator = Comparator.comparing(x->!typesFirst.contains(x.getConstraintType())); for(DBConstraint constr : diff.entriesOnlyOnRight().values().stream().sorted(pksFirstComparator).collect(Collectors.toList()) ) { - createConstraint(restoreTable, constr, st, false); + createConstraint(restoreTable, constr, st, false /* * */); } //process intersects @@ -477,26 +244,340 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { st.close(); } } + private NameMeta getEscapedNameMeta(MetaTable table) throws ExceptionDBGit { + NameMeta nm = new NameMeta(); + String schema = DBAdapterPostgres.escapeNameIfNeeded(getPhisicalSchema(table.getTable().getSchema().toLowerCase())); + String tblName = DBAdapterPostgres.escapeNameIfNeeded(table.getTable().getName()); + + nm.setSchema(schema); + nm.setName(tblName); + nm.setType(DBGitMetaType.DBGitTable); + return nm; + } + + + private void restoreTableFields(MetaTable restoreTable, MetaTable existingTable, StatementLogging st) throws Exception { + String lastField = ""; + try { + NameMeta nme = getEscapedNameMeta(existingTable); + String tblSam = nme.getSchema()+"."+nme.getName(); + + MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),existingTable.getFields()); + + if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addColumns"), 0); + + List fields = diffTableFields.entriesOnlyOnLeft().values().stream() + .sorted(Comparator.comparing(DBTableField::getOrder)) + .collect(Collectors.toList()); + + for(DBTableField tblField : fields) { + lastField = tblField.getName(); + addColumn(tblSam, tblField, st); + } + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + } + + if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 2); + for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { + lastField = tblField.getName(); + dropColumn(tblSam, tblField, st); + } + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + } + + if(!diffTableFields.entriesDiffering().isEmpty()) { + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "modifyColumns"), 2); + for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { + lastField = tblField.leftValue().getName(); + + DBTableField restoreField = tblField.leftValue(); + DBTableField existingField = tblField.rightValue(); + if( !isSameTypeSql(tblField.leftValue(), tblField.rightValue()) ) { + if( true + &&(existingField.getTypeUniversal() != FieldType.BOOLEAN) + &&(restoreField.getTypeUniversal() != FieldType.BOOLEAN) + &&(existingField.getTypeUniversal() != FieldType.STRING_NATIVE) + &&(restoreField.getTypeUniversal() != FieldType.STRING_NATIVE) + && hasNotTypeSql(tblField, "json") + && hasNotTypeSql(tblField, "text[]") + && hasNotTypeSql(tblField, "text") + ){ //Lots of exclusions when this don't work + alterTypeColumn(tblSam, tblField, st); + } else { + dropColumn(tblSam, tblField.rightValue(), st); + addColumn(tblSam, tblField.leftValue(), st); + } + } + + restoreTableFieldComment(tblSam, tblField, st); + restoreTableFieldDefaultValue(tblSam, tblField, st); + + if(!tblField.leftValue().getName().equals(tblField.rightValue().getName())) { + throw new Exception("just 'differing' columns, but differs in names, was: " + tblField.rightValue().getName() + ", to restore: " + tblField.leftValue().getName()); + // st.execute( + // "alter table " + // + tblSam + // +" rename column "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.rightValue().getName()) + // +" to "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + // ); + } + } + ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + } + } catch (Exception e) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTable.getName()+"#"+lastField) + + "\n" + e.getMessage() + ); + } + } + private void createTable(StatementLogging st, MetaTable restoreTable) throws SQLException, ExceptionDBGit { + NameMeta nme = getEscapedNameMeta(restoreTable); + + String createTableDdl = MessageFormat.format( + "create table {0}.{1}() {2};\n alter table {0}.{1} owner to {3}" + ,nme.getSchema() + ,nme.getName() + ,restoreTable.getTable().getOptions().getChildren().containsKey("tablespace") + ? "tablespace " + restoreTable.getTable().getOptions().get("tablespace").getData() + : "" + ,restoreTable.getTable().getOptions().getChildren().containsKey("owner") + ? restoreTable.getTable().getOptions().get("owner").getData() + : "postgres" + + ); + if (restoreTable.getTable().getOptions().getChildren().containsKey("partkeydef")) { + createTableDdl = createTableDdl.replace(" ) ", ") PARTITION BY " + + restoreTable.getTable().getOptions().getChildren().get("partkeydef") + + " "); + } + + st.execute(createTableDdl); + } + private void restoreTableOwner(StatementLogging st, MetaTable restoreTable, MetaTable existingTable) throws SQLException, ExceptionDBGit { + String schema = DBAdapterPostgres.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase())); + String tblName = DBAdapterPostgres.escapeNameIfNeeded(restoreTable.getTable().getName()); + + StringProperties exOwner= existingTable.getTable().getOptions().get("owner"); + StringProperties restoreOwner = restoreTable.getTable().getOptions().get("owner"); + if(restoreOwner != null && ( exOwner == null || !exOwner.getData().equals(restoreOwner.getData()) ) ){ + String alterTableDdl = MessageFormat.format( + "alter table {0}.{1} owner to {2};\n" + ,schema + ,tblName + ,restoreTable.getTable().getOptions().get("owner").getData() + ); + st.execute(alterTableDdl); + } + } + private void restoreTableTablespace(StatementLogging st, MetaTable restoreTable, MetaTable existingTable) throws SQLException, ExceptionDBGit { + NameMeta nme = getEscapedNameMeta(existingTable); + + StringProperties exTablespace = existingTable.getTable().getOptions().get("tablespace"); + StringProperties restoreTablespace = restoreTable.getTable().getOptions().get("tablespace"); + if(restoreTablespace != null && + ( exTablespace == null || !exTablespace.getData().equals(restoreTablespace.getData()) ) ){ + //TODO For now in postgres context tablespace is always missing! + String alterTableDdl = MessageFormat.format( + "alter table {0}.{1} set tablespace {2};\n" + ,nme.getSchema() + ,nme.getName() + ,restoreTable.getTable().getOptions().get("tablespace").getData() + ); + st.execute(alterTableDdl); + } + } + + + //TODO removeMetaObject + private void freeTableSequences(DBTable tbl, Connection conn, StatementLogging st) throws SQLException { + Statement stService = conn.createStatement(); + ResultSet rsSequences = stService.executeQuery("SELECT n.nspname as schema, s.relname as sequence, t.relname as table\n" + + " FROM pg_class s, pg_depend d, pg_class t, pg_attribute a, pg_namespace n \n" + + " WHERE s.relkind = 'S' \n" + + " AND n.oid = s.relnamespace \n" + + " AND d.objid = s.oid \n" + + " AND d.refobjid = t.oid \n" + + " AND (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum)\n" + + " AND n.nspname = '"+tbl.getSchema()+"' AND t.relname = '"+tbl.getName()+"'"); + + while (rsSequences.next()) st.execute(MessageFormat.format( + "ALTER SEQUENCE {0}.{1} OWNED BY NONE" + , rsSequences.getString("schema") + , rsSequences.getString("sequence")) + ); + + stService.close(); + } + + + //TODO restoreTablePostgres + private void restoreTableComment(MetaTable restoreTable, MetaTable existingTable, Statement st) throws ExceptionDBGit, SQLException + { + + String restoreTableComment = restoreTable.getTable().getComment(); + String existingTableComment = existingTable.getTable().getComment(); + boolean restoreCommentPresent = restoreTableComment != null && restoreTableComment.length() > 0; + boolean existingCommentPresent = existingTableComment != null && existingTableComment.length() > 0; + + if (restoreCommentPresent){ + boolean commentsDiffer = !existingCommentPresent || !existingTableComment.equals(restoreTableComment); + if(commentsDiffer){ + st.execute(MessageFormat.format( + "COMMENT ON TABLE {0}.{1} IS ''{2}''" + ,DBAdapterPostgres.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema())) + ,DBAdapterPostgres.escapeNameIfNeeded(restoreTable.getTable().getName()) + ,restoreTableComment + )); + } + } + } + private void restoreTablePartition(MetaTable restoreTable, Statement st) throws ExceptionDBGit, SQLException + { + NameMeta nme = getEscapedNameMeta(restoreTable); + StringProperties parent = restoreTable.getTable().getOptions().getChildren().get("parent"); + StringProperties pg_get_expr = restoreTable.getTable().getOptions().getChildren().get("pg_get_expr"); + + if(parent != null && pg_get_expr != null){ + st.execute(MessageFormat.format( + "ALTER TABLE {0}.{1} ATTACH PARTITION {0}.{2} {3}" + , nme.getSchema() + , parent + , nme.getName() + , pg_get_expr + )); + } + + } + + + //TODO restoreTableConstraintPostgres private void createConstraint(MetaTable restoreTable, DBConstraint constr, StatementLogging st, boolean replaceExisting) throws Exception { - String schema = getPhisicalSchema(constr.getSchema()); - String tableSam = DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(restoreTable.getTable().getName()); + NameMeta nme = getEscapedNameMeta(restoreTable); + String tblSam = nme.getSchema()+"."+nme.getName(); String constrName = DBAdapterPostgres.escapeNameIfNeeded(constr.getName()); - String constrDdl = (replaceExisting) ? MessageFormat.format("alter table {0} drop constraint {1};\n", tableSam, constrName) : ""; + String constrDdl = (replaceExisting) ? MessageFormat.format("alter table {0} drop constraint {1};\n", tblSam, constrName) : ""; constrDdl += MessageFormat.format( "alter table {0} add constraint {1} {2};\n" - ,tableSam + ,tblSam ,constrName ,constr.getSql() - .replace(" " + constr.getSchema() + ".", " " + schema + ".") - .replace("REFERENCES ", "REFERENCES " + schema + ".") + .replace(" " + constr.getSchema() + ".", " " + nme.getSchema() + ".") + .replace("REFERENCES ", "REFERENCES " + nme.getSchema() + ".") ); + + //dont create constraint on table with 'parent' key if (!restoreTable.getTable().getOptions().getChildren().containsKey("parent")) st.execute(constrDdl); } - public void removeTableConstraintsPostgres(IMetaObject obj) throws Exception { + //TODO restoreTableFields + private void addColumn(String tblSam, DBTableField tblField, Statement st ) throws SQLException { + String fieldName = DBAdapterPostgres.escapeNameIfNeeded(tblField.getName()); + st.execute( + "alter table "+ tblSam +" add column " + + fieldName + " " + + tblField.getTypeSQL().replace("NOT NULL", "") + ); + if (tblField.getDescription() != null && tblField.getDescription().length() > 0) + st.execute( + "COMMENT ON COLUMN " + tblSam + "." + + fieldName + + " IS '" + tblField.getDescription() + "'" + ); + + if (!tblField.getIsNullable()) { + st.execute( + "alter table " + tblSam + + " alter column " + fieldName + + " set not null" + ); + } + + if (tblField.getDefaultValue() != null && tblField.getDefaultValue().length() > 0) { + st.execute( + "alter table " + tblSam + " alter column " + fieldName + + " SET DEFAULT " + tblField.getDefaultValue() + ); + } + + } + private void dropColumn(String tblSam, DBTableField tblField, Statement st) throws SQLException { + st.execute("alter table "+ tblSam +" drop column "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.getName())); + } + private boolean isSameTypeSql(DBTableField left, DBTableField right){ + return left.getTypeSQL().equals(right.getTypeSQL()); + } + + private boolean hasNotTypeSql(ValueDifference field, String typeSql){ + return !field.leftValue().getTypeSQL().contains(typeSql) && + !field.rightValue().getTypeSQL().contains(typeSql); + } + private void alterTypeColumn(String tblSam, ValueDifference tblField, Statement st) throws SQLException + { + st.execute(MessageFormat.format("ALTER TABLE {0} ALTER COLUMN {1} TYPE {2} USING ({3}::{4})" + , tblSam + , DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + , tblField.leftValue().getTypeSQL().replace("NOT NULL", "") + , DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + , tblField.leftValue().getTypeSQL().replace("NOT NULL", "") + )); + + if (!tblField.leftValue().getIsNullable()) { + st.execute(MessageFormat.format("ALTER TABLE {0} ALTER COLUMN {1} SET NOT NULL" + , tblSam + , DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + )); + } + } + private void restoreTableFieldComment(String tableSam, ValueDifference tblField, Statement st) throws SQLException + { + + String restoreDesc = tblField.leftValue().getDescription(); + String existingDesc = tblField.rightValue().getDescription(); + boolean restoreDescPresent = restoreDesc != null && restoreDesc.length() > 0; + + if (restoreDescPresent){ + boolean existingDescPresent = existingDesc != null && existingDesc.length() > 0; + boolean needsUpdate = !existingDescPresent || !existingDesc.equals(restoreDesc); + if(needsUpdate){ + st.execute(MessageFormat.format( + "COMMENT ON COLUMN {0}.{1} IS ''{2}''" + ,tableSam + ,DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + ,restoreDesc + )); + } + } + } + private void restoreTableFieldDefaultValue(String tableSam, ValueDifference tblField, Statement st) throws ExceptionDBGit, SQLException + { + + String restoreDefault = tblField.leftValue().getDefaultValue(); + String existingDefault = tblField.rightValue().getDefaultValue(); + boolean restoreDefaultPresent = restoreDefault != null && restoreDefault.length() > 0; + + if (restoreDefaultPresent){ + boolean existingDescPresent = existingDefault != null && existingDefault.length() > 0; + boolean needsUpdate = !existingDescPresent || !existingDefault.equals(restoreDefault); + if(needsUpdate){ + st.execute(MessageFormat.format( + "ALTER TABLE {0} ALTER COLUMN {1} SET DEFAULT {2}" + ,tableSam + ,DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + ,restoreDefault + )); + } + } + } + + + //TODO unused + private void removeTableIndexesPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -505,24 +586,27 @@ public void removeTableConstraintsPostgres(IMetaObject obj) throws Exception { MetaTable table = (MetaTable)obj; String schema = getPhisicalSchema(table.getTable().getSchema()); - Map constraints = table.getConstraints(); - for(DBConstraint constrs :constraints.values()) { - st.execute( - "alter table "+ DBAdapterPostgres.escapeNameIfNeeded(schema) +"."+DBAdapterPostgres.escapeNameIfNeeded(table.getTable().getName()) - +" drop constraint if exists "+DBAdapterPostgres.escapeNameIfNeeded(constrs.getName()) - ); + + Map indices = table.getIndexes(); + for(DBIndex index :indices.values()) { + if(table.getConstraints().containsKey(index.getName())) { continue; } + + st.execute(MessageFormat.format( + "DROP INDEX IF EXISTS {0}.{1}" + ,DBAdapterPostgres.escapeNameIfNeeded(schema) +// ,DBAdapterPostgres.escapeNameIfNeeded(table.getTable().getName()) + ,DBAdapterPostgres.escapeNameIfNeeded(index.getName()) + )); } } else { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } } - - public void removeTableIndexesPostgres(IMetaObject obj) throws Exception { + private void removeTableConstraintsPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -530,19 +614,18 @@ public void removeTableIndexesPostgres(IMetaObject obj) throws Exception { if (obj instanceof MetaTable) { MetaTable table = (MetaTable)obj; String schema = getPhisicalSchema(table.getTable().getSchema()); + MetaTable dbTable = (MetaTable) GitMetaDataManager.getInstance().getCacheDBMetaObject(obj.getName()); - Map constraints = table.getIndexes(); - for(DBIndex constrs :constraints.values()) { - st.execute(MessageFormat.format( - "alter table {0}.{1} drop index if exists {2}" - ,DBAdapterPostgres.escapeNameIfNeeded(schema) - ,DBAdapterPostgres.escapeNameIfNeeded(table.getTable().getName()) - ,DBAdapterPostgres.escapeNameIfNeeded(constrs.getName()) - )); + + Map constraints = dbTable.getConstraints(); + for(DBConstraint constrs :constraints.values()) { + st.execute( + "alter table "+ DBAdapterPostgres.escapeNameIfNeeded(schema) +"."+DBAdapterPostgres.escapeNameIfNeeded(table.getTable().getName()) + +" drop constraint if exists "+DBAdapterPostgres.escapeNameIfNeeded(constrs.getName()) + ); } } - else - { + else { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); } } catch (Exception e) { @@ -550,8 +633,7 @@ public void removeTableIndexesPostgres(IMetaObject obj) throws Exception { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } } - - /*public void removeIndexesPostgres(IMetaObject obj) throws Exception { + /*public void removeIndexesPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -572,47 +654,4 @@ public void removeTableIndexesPostgres(IMetaObject obj) throws Exception { throw new ExceptionDBGitRestore("Error restore "+obj.getName(), e); } }*/ - - public void removeMetaObject(IMetaObject obj) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - - try { - MetaTable tblMeta = (MetaTable)obj; - DBTable tbl = tblMeta.getTable(); - if (tbl == null) return; - - String schema = getPhisicalSchema(tbl.getSchema()); - - freeTableSequences(tbl, connect, st); - st.execute("DROP TABLE "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(tbl.getName())); - } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } - - private void freeTableSequences(DBTable tbl, Connection conn, StatementLogging st) throws SQLException { - Statement stService = conn.createStatement(); - ResultSet rsSequences = stService.executeQuery("SELECT n.nspname as schema, s.relname as sequence, t.relname as table\n" + - " FROM pg_class s, pg_depend d, pg_class t, pg_attribute a, pg_namespace n \n" + - " WHERE s.relkind = 'S' \n" + - " AND n.oid = s.relnamespace \n" + - " AND d.objid = s.oid \n" + - " AND d.refobjid = t.oid \n" + - " AND (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum)\n" + - " AND n.nspname = '"+tbl.getSchema()+"' AND t.relname = '"+tbl.getName()+"'"); - - while (rsSequences.next()) st.execute(MessageFormat.format( - "ALTER SEQUENCE {0}.{1} OWNED BY NONE" - , rsSequences.getString("schema") - , rsSequences.getString("sequence")) - ); - - stService.close(); - } - } From 3cec0bb91866c30b4355b72dd440d390e4f47b63 Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 23:52:44 +0300 Subject: [PATCH 29/68] DBAdapter.java now drops all tables constraints before main restore loop (restore step -2) to fix fk dependency errors on re-creating pk's Fix autoCommit mode set to true in some occasions SortedListMetaObject.java, DBBackupAdapter.java some refactor\renames --- .../fusionsoft/dbgit/adapters/DBAdapter.java | 37 ++++++++++++++----- .../dbgit/adapters/DBBackupAdapter.java | 5 +-- .../dbgit/meta/SortedListMetaObject.java | 22 ++++++----- 3 files changed, 43 insertions(+), 21 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index b693fd9..595f2c6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -15,7 +15,6 @@ import java.sql.ResultSet; import java.sql.Timestamp; import java.text.MessageFormat; -import java.util.ArrayList; import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; @@ -45,10 +44,10 @@ public Connection getConnection() { int pauseTimeSeconds = DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000)); int currentTry = 0; - if (connect.isValid(0)) + if (connect.isValid(0)){ + connect.setAutoCommit(false); return connect; - - else { + } else { ConsoleWriter.println("Connection lost, trying to reconnect..."); while (currentTry <= maxTriesCount) { TimeUnit.SECONDS.sleep(pauseTimeSeconds); @@ -60,6 +59,7 @@ public Connection getConnection() { conn = DBConnection.getInstance(true); ConsoleWriter.println("Successful reconnect"); connect = conn.getConnect(); + connect.setAutoCommit(false); return connect; } } @@ -92,11 +92,19 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { DBGitLang lang = DBGitLang.getInstance(); try { - List tables = new ArrayList<>(); + SortedListMetaObject tables = new SortedListMetaObject(updateObjs.values().stream().filter(x->x instanceof MetaTable ).collect(Collectors.toList())); + SortedListMetaObject tablesExists = new SortedListMetaObject(updateObjs.values().stream().filter(x->x instanceof MetaTable && isExists(x)).collect(Collectors.toList())); + Set createdSchemas = getSchemes().values().stream().map(DBOptionsObject::getName).collect(Collectors.toSet()); Set createdRoles = getRoles().values().stream().map(DBRole::getName).collect(Collectors.toSet()); - for (IMetaObject obj : updateObjs.getSortedList().sortFromFree()) { + // remove table indexes and constraints, which is step(-2) of restoreMetaObject(MetaTable) + ConsoleWriter.println("Dropping constraints for all updating tables..."); + for (IMetaObject table : tablesExists.sortFromDependencies()) { + getFactoryRestore().getAdapterRestore(DBGitMetaType.DBGitTable, this).restoreMetaObject(table, -2); + } + + for (IMetaObject obj : updateObjs.getSortedList().sortFromReferenced()) { Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); int step = 0; boolean res = false; @@ -113,7 +121,6 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { res = restoreAdapter.restoreMetaObject(obj, step++); if (step > 100) { throw new Exception(lang.getValue("errors", "restore", "restoreErrorDidNotReturnTrue").toString()); } - if (obj instanceof MetaTable){ tables.add((MetaTable) obj); } } Long timeDiff = new Timestamp(System.currentTimeMillis()).getTime() - timestampBefore.getTime(); @@ -121,7 +128,8 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { } // restore table constraints, which is step(-1) of restoreMetaObject(MetaTable) - for (MetaTable table : tables) { + ConsoleWriter.println("Restoring constraints for all updated tables..."); + for (IMetaObject table : tables.sortFromReferenced()) { getFactoryRestore().getAdapterRestore(DBGitMetaType.DBGitTable, this).restoreMetaObject(table, -1); } connect.commit(); @@ -144,7 +152,7 @@ public void deleteDataBase(IMapMetaObject deleteObjs, boolean isDeleteFromIndex) DBGitIndex index = DBGitIndex.getInctance(); try { - List deleteObjsSorted = deleteObjs.getSortedList().sortFromDependant(); + List deleteObjsSorted = deleteObjs.getSortedList().sortFromDependencies(); for (IMetaObject obj : deleteObjsSorted) { getFactoryRestore().getAdapterRestore(obj.getType(), this).removeMetaObject(obj); if(isDeleteFromIndex) index.removeItem(obj); @@ -219,6 +227,17 @@ private void createRoleIfNeed(IMetaObject obj, Set createdRoles) throws } } + protected boolean isExists(IMetaObject obj){ + try{ + IDBBackupAdapter backupAdapter = getBackupAdapterFactory().getBackupAdapter(AdapterFactory.createAdapter()); + return backupAdapter.isExists( + obj.getUnderlyingDbObject().getSchema(), + obj.getUnderlyingDbObject().getName() + ); + } catch (Exception ex) { + return false; + } + } private boolean checkContainsNativeFields(IMetaObject obj){ if (obj instanceof MetaTable) { diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java index 185fb0c..c3cd975 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java @@ -7,7 +7,6 @@ import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import java.sql.Timestamp; import java.text.MessageFormat; import java.util.*; import java.util.function.Function; @@ -128,7 +127,7 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { dropList.addAll(dbDroppingBackups.values()); dropList.addAll(dbDroppingBackupsDeps); - List dropListSorted = new SortedListMetaObject(dropList).sortFromDependant(); + List dropListSorted = new SortedListMetaObject(dropList).sortFromDependencies(); ConsoleWriter.printlnGreen(MessageFormat.format("Rewriting {0} backups with {1} dependencies", dbDroppingBackups.size(), dbDroppingBackupsDeps.size())); dropListSorted.forEach( x -> ConsoleWriter.detailsPrintlnGreen( x.getName())); @@ -143,7 +142,7 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { } //create backups - for(IMetaObject imo : dbToBackup.getSortedList().sortFromFree()){ + for(IMetaObject imo : dbToBackup.getSortedList().sortFromReferenced()){ backupDBObject(imo); } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java index 9879eb0..fa60373 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java @@ -64,6 +64,9 @@ private void calculateImoCrossDependencies(){ // long diff = timestampAfter.getTime() - timestampBefore.getTime(); // ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "time").withParams(Long.toString(diff))); } + public Collection getCollection(){ + return collection; + } public List createSortedList(boolean isSortedFromFree) throws ExceptionDBGit { List list = new ArrayList<>(); @@ -85,11 +88,11 @@ public List createSortedList(boolean isSortedFromFree) throws Excep if (tp.equals(DBGitMetaType.DBGitTable) || objectsOfType.get(0) instanceof MetaSql) { Set namesAllOfType = objectsOfType.stream().map(IMetaObject::getName).collect(Collectors.toSet()); List objectsL0 = objectsOfType.stream() - .filter(x -> { - Set deps = x.getUnderlyingDbObject().getDependencies(); - return deps.size() == 0 || ( deps.size() == 1 && deps.contains(x.getName()) ); - }) - .collect(Collectors.toList()); + .filter(x -> { + Set deps = x.getUnderlyingDbObject().getDependencies(); + return deps.size() == 0 || ( deps.size() == 1 && deps.contains(x.getName()) ); + }) + .collect(Collectors.toList()); objectsOfType.removeAll(objectsL0); while (!objectsOfType.isEmpty()) { @@ -98,7 +101,7 @@ public List createSortedList(boolean isSortedFromFree) throws Excep .stream() .filter(x -> { Set actualDeps = new HashSet<>(x.getUnderlyingDbObject().getDependencies()); - actualDeps.retainAll(namesAllOfType); + actualDeps.retainAll(namesAllOfType); //only deps of same type actualDeps.remove(x.getName()); return namesL0.containsAll(actualDeps); }) @@ -109,7 +112,8 @@ public List createSortedList(boolean isSortedFromFree) throws Excep throw new ExceptionDBGit("infinite loop"); } objectsOfType.removeAll(objectsL1); - if(isSortedFromFree) { objectsL0.addAll(objectsL1); } else { objectsL0.addAll(0, objectsL1); } + if(isSortedFromFree) { objectsL0.addAll(objectsL1); } + else { objectsL0.addAll(0, objectsL1); } } list.addAll(objectsL0); } else { @@ -125,14 +129,14 @@ public List createSortedList(boolean isSortedFromFree) throws Excep return list; } - public List sortFromDependant() throws ExceptionDBGit { + public List sortFromDependencies() throws ExceptionDBGit { if (listFromDependant == null) { listFromDependant = createSortedList(false); } return listFromDependant; } - public List sortFromFree() throws ExceptionDBGit { + public List sortFromReferenced() throws ExceptionDBGit { if (listFromFree == null) { listFromFree = createSortedList(true); } From d4d4130c55ef65eac06f17c3a8b6382c0e22a8d6 Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 23:57:10 +0300 Subject: [PATCH 30/68] CmdRestore.java add enrich restore objects list with dependant MetaTables to fix major errors on schema restore with pk\fk change See the last commit that also prepare to fix this group of errors --- .../fusionsoft/dbgit/command/CmdRestore.java | 30 +++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java index 47c627e..179c4fc 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java @@ -6,8 +6,9 @@ import java.nio.file.Files; import java.text.SimpleDateFormat; import java.util.Date; +import java.util.Map; +import java.util.stream.Collectors; -import com.google.common.collect.Lists; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.Options; @@ -67,7 +68,6 @@ public void execute(CommandLine cmdLine) throws Exception { IMapMetaObject updateObjs = new TreeMapMetaObject(); IMapMetaObject deleteObjs = new TreeMapMetaObject(); - ConsoleWriter.println(""); if (toMakeBackup) { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "willMakeBackup").toString()); } if (toMakeChanges) { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "toMakeChanges").toString()); } else { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "notMakeChanges").withParams(autoScriptFile.getAbsolutePath())); } @@ -113,6 +113,32 @@ public void execute(CommandLine cmdLine) throws Exception { } } + // to fix pk constraint re-creation error + // collect other file objects that depend on update objects + // to re-create their fk constraints too, so we: + + // 0. enrich update list with fk-dependant objects from database + // 1. drop all of constraints + // 2. re-create all constraints in default sorted order + + // # steps 1,2 are in GitMetaDataManager::restoreDatabase + Map affectedTables = dbObjs.values().stream().filter(excluded -> + excluded instanceof MetaTable && + !updateObjs.containsKey(excluded.getName()) && + updateObjs.values().stream().anyMatch( included -> excluded.dependsOn(included) ) + ).collect(Collectors.toMap( key -> key.getName(), val -> val)); + + + if(affectedTables.isEmpty()){ + ConsoleWriter.printlnRed("No affected tables..."); + } else { + ConsoleWriter.printlnRed("Affected tables:"); + affectedTables.forEach((k,v)->ConsoleWriter.printlnRed("\t"+k)); + updateObjs.putAll( affectedTables ); + } + + + if(toMakeBackup && toMakeChanges) { IMapMetaObject backupObjs = new TreeMapMetaObject(); backupObjs.putAll(deleteObjs); From 5e186fc85ab50af00053c287a4aa955060685abf Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 23:57:56 +0300 Subject: [PATCH 31/68] Make BACKUP_TO_SCHEME = true by default --- src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java index 249dd42..4f08dee 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java @@ -167,7 +167,7 @@ public static boolean createDefaultDbgitConfig(String path) throws ExceptionDBGi writer.write("LANG = ENG\n"); writer.write("SCRIPT_ROTATE = 31\n"); writer.write("TO_MAKE_BACKUP = false\n"); - writer.write("BACKUP_TO_SCHEME = false\n"); + writer.write("BACKUP_TO_SCHEME = true\n"); writer.write("BACKUP_TABLEDATA = true\n"); writer.write("PORTION_SIZE = 50000\n"); writer.write("TRY_COUNT = 1000\n"); From 51e8fa000ad147dff2306fea1c84e6473781f0fa Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 6 Nov 2020 23:59:22 +0300 Subject: [PATCH 32/68] ExceptionDBGit* change some behaviour to see better detailed error messages, also aware of -verbose call option --- .../fusionsoft/dbgit/core/ExceptionDBGit.java | 25 +++++++++++++------ .../dbgit/core/ExceptionDBGitRestore.java | 3 --- .../dbgit/core/ExceptionDBGitRunTime.java | 11 ++++++-- 3 files changed, 27 insertions(+), 12 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java index b0c7437..9004cd8 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java @@ -24,12 +24,27 @@ public ExceptionDBGit(Object msg) { } public ExceptionDBGit(String msg) { - this(msg, new Exception(msg)); + super(msg); + rollbackConnection(); + ConsoleWriter.printlnRed(msg); + ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(this)); + logger.error(msg); + System.exit(1); } public ExceptionDBGit(String message, Throwable cause) { - super(message, cause); +// super(message, cause); + rollbackConnection(); + ConsoleWriter.printlnRed(message); + if(!cause.getMessage().equals(message)) { + ConsoleWriter.printlnRed(cause.getLocalizedMessage()); + } + ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(cause)); logger.error(message, cause); + System.exit(1); + } + + private void rollbackConnection() { try{ DBConnection conn = DBConnection.getInstance(); conn.getConnect().rollback(); @@ -40,12 +55,8 @@ public ExceptionDBGit(String message, Throwable cause) { ConsoleWriter.printlnRed(ex.getLocalizedMessage()); } } - ConsoleWriter.printlnRed(message); - ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(cause)); - logger.error(message, cause); - System.exit(1); } - + public ExceptionDBGit(Throwable cause) { super(cause); logger.error(cause.getLocalizedMessage(), cause); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java index c9527e5..be8e8f0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java @@ -8,16 +8,13 @@ public class ExceptionDBGitRestore extends ExceptionDBGit { public ExceptionDBGitRestore(String msg) { super(msg); - ConsoleWriter.println("\n" + msg); } public ExceptionDBGitRestore(String message, Throwable cause) { super(message, cause); - ConsoleWriter.println("\n" + message + "\n" + cause.getLocalizedMessage()); } public ExceptionDBGitRestore(Throwable cause) { super(cause); - ConsoleWriter.println(cause.getLocalizedMessage()); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java index 60ae571..87a27d7 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java @@ -28,8 +28,15 @@ public ExceptionDBGitRunTime(String message, Throwable cause) { ConsoleWriter.printlnRed(ex.getLocalizedMessage()); } } - ConsoleWriter.printlnRed(message); - ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(cause)); + ConsoleWriter.printlnRed(message ); + + if(cause instanceof SQLException){ + ConsoleWriter.printlnRed(ExceptionUtils.getStackTrace(cause)); + + } else if ( !message.equals(cause.getMessage()) ){ + ConsoleWriter.printlnRed(cause.getMessage() ); + ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(cause)); + } logger.error(message, cause); System.exit(1); From 8f7de1d419f905b41d6496ebd433c7d6d725faa7 Mon Sep 17 00:00:00 2001 From: rocket Date: Sat, 7 Nov 2020 00:01:47 +0300 Subject: [PATCH 33/68] Some tests added for testing .dbignore matching behavior --- .../dbgit/core/DBGitIgnoreTest.java | 32 +++++++++++++++++++ .../dbgit/utils/MaskFilterTest.java | 29 +++++++++++++++++ 2 files changed, 61 insertions(+) create mode 100644 src/test/java/ru/fusionsoft/dbgit/core/DBGitIgnoreTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/utils/MaskFilterTest.java diff --git a/src/test/java/ru/fusionsoft/dbgit/core/DBGitIgnoreTest.java b/src/test/java/ru/fusionsoft/dbgit/core/DBGitIgnoreTest.java new file mode 100644 index 0000000..b75d80e --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/core/DBGitIgnoreTest.java @@ -0,0 +1,32 @@ +package ru.fusionsoft.dbgit.core; + +import ru.fusionsoft.dbgit.utils.MaskFilter; + +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.*; +import static org.junit.jupiter.api.Assertions.*; + +public class DBGitIgnoreTest { + + DBGitIgnore dbGitIgnore; + Map filters = new HashMap<>(); + Map exclusions = new HashMap<>(); + String textTbl = "public/ad_group_roles.tbl"; + + private void createDbGitIgnore(){ + dbGitIgnore = new DBGitIgnore(filters, exclusions); + addExcl("public/*.*"); + } + + private void addFilter(String mask){ filters.put(mask, new MaskFilter(mask)); } + private void addExcl(String mask){ exclusions.put(mask, new MaskFilter(mask)); } + + + + @Test + public void matchOne() { + createDbGitIgnore(); + assertFalse(dbGitIgnore.matchOne(textTbl)); + } +} \ No newline at end of file diff --git a/src/test/java/ru/fusionsoft/dbgit/utils/MaskFilterTest.java b/src/test/java/ru/fusionsoft/dbgit/utils/MaskFilterTest.java new file mode 100644 index 0000000..3a7b090 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/utils/MaskFilterTest.java @@ -0,0 +1,29 @@ +package ru.fusionsoft.dbgit.utils; + +import org.junit.jupiter.api.*; +import static org.junit.jupiter.api.Assertions.*; + +public class MaskFilterTest { + + @Test + public void match() { + MaskFilter mf = new MaskFilter("pub*.*"); + + String textTbl = "public/ad_group_roles.tbl"; + String textCsv = "public/ad_group_roles.csv"; + + assertTrue(mf.match(textTbl)); + assertTrue(mf.match(textCsv)); + } + + @Test + public void matchExtention() { + MaskFilter mfCsv = new MaskFilter("pub*lic*.csv"); + + String textTbl = "public/ad_group_roles.tbl"; + String textCsv = "public/ad_group_roles.csv"; + + assertFalse(mfCsv.match(textTbl)); + assertTrue(mfCsv.match(textCsv)); + } +} \ No newline at end of file From 251a00586c949b0d4d694f7b50fe915708f8d284 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=93=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D0=BB=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=90?= Date: Mon, 9 Nov 2020 13:31:46 +0300 Subject: [PATCH 34/68] enable tests in gitlab-ci --- .gitlab-ci.yml | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index cddc750..ff47285 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,18 +1,25 @@ image: maven:3.6.3-jdk-8 stages: -# - test + - test - build -# - deploy build: stage: build script: - time mvn package appassembler:assemble -D skipTests - mv target/dbgit dbgit + only: + refs: + - master artifacts: + expire_in: never paths: - dbgit +test: + stage: test + script: + - time mvn test cache: paths: From d5bdf2be9e0aa2ae9dff694f2be34e27dd6124b3 Mon Sep 17 00:00:00 2001 From: rocket Date: Thu, 19 Nov 2020 15:59:37 +0300 Subject: [PATCH 35/68] DBGit.initUrlInstance - added 'force' parameter not to check existence of DBGit instance + Refactor of DBAdapter.escapeNameIfNeeded - now we have IDBAdapter.escapeNameIfNeeded and implementations --- .../fusionsoft/dbgit/adapters/DBAdapter.java | 5 + .../dbgit/adapters/DBAdapterProxy.java | 5 + .../fusionsoft/dbgit/adapters/IDBAdapter.java | 4 +- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 4 +- .../ru/fusionsoft/dbgit/meta/MetaTable.java | 33 ++++++- .../dbgit/mysql/DBAdapterMySql.java | 2 +- .../dbgit/mysql/DBBackupAdapterMySql.java | 2 +- .../oracle/FactoryDBAdapterRestoreOracle.java | 3 - .../dbgit/postgres/DBAdapterPostgres.java | 13 +-- .../postgres/DBBackupAdapterPostgres.java | 28 +++--- .../postgres/DBRestoreFunctionPostgres.java | 4 +- .../postgres/DBRestoreProcedurePostgres.java | 4 +- .../postgres/DBRestoreSequencePostgres.java | 4 +- .../postgres/DBRestoreTableDataPostgres.java | 4 +- .../postgres/DBRestoreTablePostgres.java | 68 ++++++------- .../postgres/DBRestoreTriggerPostgres.java | 2 +- .../dbgit/postgres/DBRestoreViewPostgres.java | 6 +- .../java/ru/fusionsoft/dbgit/DBGitTest.java | 99 ++++++++++++------- 18 files changed, 176 insertions(+), 114 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 595f2c6..4e01397 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -286,6 +286,7 @@ private boolean isSameDbType(IMetaObject obj){ return obj.getDbType().equals(getDbType()); } private boolean isSameDbVersion(IMetaObject obj){ + if(getDbVersion().equals("13.0 (Ubuntu 13.0-1.pgdg18.04+1)")) return true; //temp hack to run on remote test db return obj.getDbVersion().equals(getDbVersion()); } @@ -299,4 +300,8 @@ public void registryMappingTypes() { FactoryCellData.regMappingTypes(FieldType.STRING_NATIVE, StringData.class); FactoryCellData.regMappingTypes(FieldType.TEXT, TextFileData.class); } + + public String escapeNameIfNeeded(String name) { + return name; + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java index 8ffda91..dac47e2 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java @@ -253,6 +253,11 @@ public boolean isReservedWord(String word) { return adapter.isReservedWord(word); } + @Override + public String escapeNameIfNeeded(String name) { + return adapter.escapeNameIfNeeded(name); + } + @Override public DBTableData getTableDataPortion(String schema, String nameTable, int portionIndex, int tryNumber) { return adapter.getTableDataPortion(schema, nameTable, portionIndex, tryNumber); diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java index 502806c..7cb4039 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java @@ -157,6 +157,8 @@ public interface IDBAdapter { public String getDefaultScheme() throws ExceptionDBGit; boolean isReservedWord(String word); - + + public String escapeNameIfNeeded(String name); + /*Если будет нужно - сюда можно добавить подписчиков на события*/ } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index 0a5ab05..d1c7eb1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -69,8 +69,8 @@ public static DBGit getInstance() throws ExceptionDBGit { } return dbGit; } - public static DBGit initUrlInstance(String gitDirUrl) throws ExceptionDBGit { - if (dbGit != null) { + public static DBGit initUrlInstance(String gitDirUrl, boolean force) throws ExceptionDBGit { + if (dbGit != null && !force) { throw new ExceptionDBGit("Already initialized"); } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java index bcff345..4bd6c27 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java @@ -11,15 +11,11 @@ import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.core.DBGitIndex; import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; -import ru.fusionsoft.dbgit.core.ItemIndex; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; import ru.fusionsoft.dbgit.dbobjects.DBIndex; -import ru.fusionsoft.dbgit.dbobjects.DBSchema; import ru.fusionsoft.dbgit.dbobjects.DBTable; import ru.fusionsoft.dbgit.dbobjects.DBTableField; import ru.fusionsoft.dbgit.utils.CalcHash; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.yaml.YamlOrder; /** @@ -129,7 +125,7 @@ public String getHash() { CalcHash ch = new CalcHash()/*{ @Override public CalcHash addData(String str){ - ConsoleWriter.detailsPrintlnGreen(str); + ConsoleWriter.printlnRed(str); return super.addData(str); } }*/; @@ -161,6 +157,24 @@ public CalcHash addData(String str){ } +// if(this.getTable() != null && this.getTable().getName().contains("clients")){ +// ConsoleWriter.printlnRed(MessageFormat.format("-\t-\t-\t-\t-\t-\ntable = {0} ; {1}, \nfields({2}) = \n{3}\nindexes({4}) = \n{5}\nconstraints({6}) = \n{7}" +// ,this.getTable() != null ? this.getTable().getName() + " ; " + truncateHash(this.getTable().getHash()) : "noname" +// ,this.getTable() != null ? this.getTable().getOptions().getChildren().entrySet().stream().map(x->"\n\t\t" + x.getKey() + " : " + x.getValue().getData()).collect(Collectors.joining("")) : "null" +// ,fields.keySet().size() +// ,fields.values().stream() +// .map(x->"\t\t" + x.getName() + ";" + x.getDefaultValue()) +// .collect(Collectors.joining("\n")) +// ,indexes.keySet().size() +// ,indexes.values().stream() +// .map(x->"\t\t" + x.getName() + ";" + truncateHash(x.getHash())) +// .collect(Collectors.joining("\n")) +// ,constraints.keySet().size() +// ,constraints.values().stream() +// .map(x->"\t\t" + x.getName() + ";" + truncateHash(x.getHash())) +// .collect(Collectors.joining("\n")) +// )); +// } return ch.calcHashStr(); } @@ -230,4 +244,13 @@ public List getIdColumns() { return idColumns; } +// private String truncateHash(String hash){ +// return hash.substring( +// 0, +// 2 +// ) + hash.substring( +// hash.length() - 3, +// hash.length() - 1 +// ); +// } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java index b110e44..1169ffb 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java @@ -61,7 +61,7 @@ public class DBAdapterMySql extends DBAdapter { private FactoryDBBackupAdapterMySql backupFactory = new FactoryDBBackupAdapterMySql(); public static Set reservedWords; - public static Object escapeNameIfNeeded(String name) { + public String escapeNameIfNeeded(String name) { boolean shouldBeEscaped = false; //TODO Permitted characters in unquoted identifiers: //ASCII: [0-9,a-z,A-Z$_] (basic Latin letters, digits 0-9, dollar, underscore) diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java index a88c165..625e397 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java @@ -205,7 +205,7 @@ public void dropIfExists(IMetaObject imo, StatementLogging stLog) throws SQLExce stLog.execute(MessageFormat.format("DROP {0} {1}.{2}", rs.getString("tp"), nm.getSchema(), - DBAdapterMySql.escapeNameIfNeeded(nm.getName())) + adapter.escapeNameIfNeeded(nm.getName())) ); } diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDBAdapterRestoreOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDBAdapterRestoreOracle.java index a1808a8..d36af5c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDBAdapterRestoreOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDBAdapterRestoreOracle.java @@ -1,12 +1,9 @@ package ru.fusionsoft.dbgit.oracle; -import java.sql.Connection; import java.util.Collections; import java.util.HashMap; import java.util.Map; -import ru.fusionsoft.dbgit.adapters.DBRestoreMetaNotSupport; -import ru.fusionsoft.dbgit.adapters.DBRestoreMetaSql; import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapterRestoreMetaData; import ru.fusionsoft.dbgit.adapters.IFactoryDBAdapterRestoteMetaData; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index a2349b4..a178929 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -812,7 +812,7 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port if (DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true))) { Statement st = getConnection().createStatement(); String query = "select COALESCE(count(*), 0) kolvo from ( select 1 from "+ - DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(nameTable) + " limit " + (maxRowsCount + 1) + " ) tbl"; + escapeNameIfNeeded(schema) + "." + escapeNameIfNeeded(nameTable) + " limit " + (maxRowsCount + 1) + " ) tbl"; ResultSet rs = st.executeQuery(query); rs.next(); if (rs.getInt("kolvo") > maxRowsCount) { @@ -827,9 +827,10 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port int end = portionSize + portionSize*portionIndex; Statement st = getConnection().createStatement(); - String query = " SELECT * FROM \r\n" + - " (SELECT f.*, ROW_NUMBER() OVER (ORDER BY ctid) DBGIT_ROW_NUM FROM " + DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(nameTable) + " f) s\r\n" + - " WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end; + String query = + " SELECT * FROM \r\n" + + " (SELECT f.*, ROW_NUMBER() OVER (ORDER BY ctid) DBGIT_ROW_NUM FROM " + escapeNameIfNeeded(schema) + "." + escapeNameIfNeeded(nameTable) + " f) s\r\n" + + " WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end; ResultSet rs = st.executeQuery(query); data.setResultSet(rs); @@ -865,7 +866,7 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port @Override public DBTableData getTableData(String schema, String nameTable) { - String tableName = DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+ DBAdapterPostgres.escapeNameIfNeeded(nameTable); + String tableName = escapeNameIfNeeded(schema)+"."+ escapeNameIfNeeded(nameTable); try { DBTableData data = new DBTableData(); @@ -1040,7 +1041,7 @@ public boolean isReservedWord(String word) { } - public static String escapeNameIfNeeded(String name){ + public String escapeNameIfNeeded(String name){ boolean shouldBeEscaped = !name.equals(name.toLowerCase()) || name.contains(".") || name.contains(".") diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java index 95f692a..18e26a0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java @@ -82,8 +82,8 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio StringBuilder tableDdlSb = new StringBuilder(MessageFormat.format( "create table {0} as (select * from {1}.{2} where 1={3}) {4};\n alter table {0} owner to {5};\n" , backupTableSam - , DBAdapterPostgres.escapeNameIfNeeded(schema) - , DBAdapterPostgres.escapeNameIfNeeded(tableName) + , adapter.escapeNameIfNeeded(schema) + , adapter.escapeNameIfNeeded(tableName) , isToSaveData() ? "1" : "0" //TableData , metaTable.getTable().getOptions().getChildren().containsKey("tablespace") ? " tablespace " + metaTable.getTable().getOptions().get("tablespace").getData() @@ -97,10 +97,10 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio String fkname = fk.substring(fk.indexOf('/')+1,fk.lastIndexOf('.')) ; String fkschema = fk.substring(0,fk.indexOf('/')) ; - String nameDb = "("+fkschema+ "\\.)?" + "\\\"?" + Pattern.quote(DBAdapterPostgres.escapeNameIfNeeded(fkname)) + "\\\"?(?=\\()"; + String nameDb = "("+fkschema+ "\\.)?" + "\\\"?" + Pattern.quote(adapter.escapeNameIfNeeded(fkname)) + "\\\"?(?=\\()"; String nameReplacement = isSaveToSchema() - ? Matcher.quoteReplacement(DBAdapterPostgres.escapeNameIfNeeded(PREFIX+fkschema) + "." + fkname) - : Matcher.quoteReplacement(fkschema + "." + DBAdapterPostgres.escapeNameIfNeeded(PREFIX+fkname)); + ? Matcher.quoteReplacement(adapter.escapeNameIfNeeded(PREFIX+fkschema) + "." + fkname) + : Matcher.quoteReplacement(fkschema + "." + adapter.escapeNameIfNeeded(PREFIX+fkname)); fkRefReplaces.put(nameDb, nameReplacement); } @@ -108,7 +108,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio for (DBIndex index : metaTable.getIndexes().values()) { String indexName = index.getName(); String indexNameRe = "\\\"?" + Pattern.quote(indexName) + "\\\"?"; - String backupIndexNameRe = Matcher.quoteReplacement(DBAdapterPostgres.escapeNameIfNeeded( + String backupIndexNameRe = Matcher.quoteReplacement(adapter.escapeNameIfNeeded( PREFIX + indexName + ((metaTable.getConstraints().containsKey(index.getName())) ? "_idx" : "") )); @@ -126,10 +126,10 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio } for (DBConstraint constraint : metaTable.getConstraints().values().stream().sorted(Comparator.comparing(x->!x.getName().toLowerCase().contains("pk"))).collect(Collectors.toList())) { - String name = DBAdapterPostgres.escapeNameIfNeeded(PREFIX + constraint.getName()); + String name = adapter.escapeNameIfNeeded(PREFIX + constraint.getName()); String constrName = constraint.getName(); String constrNameRe = "\\\"?" + Pattern.quote(constrName) + "\\\"?"; - String backupConstrNameRe = Matcher.quoteReplacement(DBAdapterPostgres.escapeNameIfNeeded(PREFIX + constrName)); + String backupConstrNameRe = Matcher.quoteReplacement(adapter.escapeNameIfNeeded(PREFIX + constrName)); String constrDef = constraint.getSql().replaceAll(constrNameRe, backupConstrNameRe); for(String reference : fkRefReplaces.keySet()){ constrDef = constrDef.replaceAll(reference, fkRefReplaces.get(reference)); } @@ -210,10 +210,10 @@ public void restoreDBObject(IMetaObject obj) throws Exception { private String getFullDbName(String schema, String objectName) { if (isSaveToSchema()){ - return DBAdapterPostgres.escapeNameIfNeeded(PREFIX + schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(objectName); + return adapter.escapeNameIfNeeded(PREFIX + schema) + "." + adapter.escapeNameIfNeeded(objectName); } else { - return DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(PREFIX + objectName); + return adapter.escapeNameIfNeeded(schema) + "." + adapter.escapeNameIfNeeded(PREFIX + objectName); } } @@ -230,7 +230,7 @@ public void dropIfExists(String owner, String objectName, StatementLogging stLog "where sch = '" + owner.toLowerCase() + "' and obj_name = '"+objectName+"'"); while (rs.next()) { - stLog.execute("drop " + rs.getString("tp") + " " + DBAdapterPostgres.escapeNameIfNeeded(owner) + "." + DBAdapterPostgres.escapeNameIfNeeded(objectName)); + stLog.execute("drop " + rs.getString("tp") + " " + adapter.escapeNameIfNeeded(owner) + "." + adapter.escapeNameIfNeeded(objectName)); } rs.close(); @@ -260,8 +260,8 @@ public void dropIfExists(IMetaObject imo, StatementLogging stLog) throws Excepti while (rs.next()) { stLog.execute(MessageFormat.format("DROP {0} {1}.{2}", rs.getString("tp"), - DBAdapterPostgres.escapeNameIfNeeded(nm.getSchema()), - DBAdapterPostgres.escapeNameIfNeeded(nm.getName()) + adapter.escapeNameIfNeeded(nm.getSchema()), + adapter.escapeNameIfNeeded(nm.getName()) )); } @@ -300,7 +300,7 @@ public boolean createSchema(StatementLogging stLog, String schema) { rs.next(); if (rs.getInt("cnt") == 0) { ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema)); - stLog.execute("create schema " + DBAdapterPostgres.escapeNameIfNeeded(PREFIX + schema)); + stLog.execute("create schema " + adapter.escapeNameIfNeeded(PREFIX + schema)); } rs.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java index 4073388..2d01817 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java @@ -50,7 +50,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { st.execute(MessageFormat.format("ALTER FUNCTION {0}.{1}({2}) OWNER TO {3}" , restoreFunction.getUnderlyingDbObject().getSchema() - , DBAdapterPostgres.escapeNameIfNeeded(restoreFunctionName) + , adapter.escapeNameIfNeeded(restoreFunctionName) , args , restoreFunction.getSqlObject().getOwner())); } @@ -92,7 +92,7 @@ public void removeMetaObject(IMetaObject obj) throws Exception { if (fnc == null) return; String schema = getPhisicalSchema(fnc.getSchema()); - st.execute("DROP FUNCTION "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(fnc.getName())); + st.execute("DROP FUNCTION "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(fnc.getName())); } catch (Exception e) { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java index 97ff621..ee1f510 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java @@ -51,7 +51,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { st.execute(MessageFormat.format("ALTER PROCEDURE {0}.{1}({2}) OWNER TO {3}" , nm.getSchema() - , DBAdapterPostgres.escapeNameIfNeeded(restoreProcName) + , adapter.escapeNameIfNeeded(restoreProcName) , args , restoreProc.getSqlObject().getOwner())); } @@ -94,7 +94,7 @@ public void removeMetaObject(IMetaObject obj) throws Exception if (prc == null) return; String schema = getPhisicalSchema(prc.getSchema()); - st.execute("DROP PROCEDURE "+schema+"."+DBAdapterPostgres.escapeNameIfNeeded(prc.getName())); + st.execute("DROP PROCEDURE "+schema+"."+adapter.escapeNameIfNeeded(prc.getName())); } catch (Exception e) { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java index 8576957..74ccc5d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java @@ -61,7 +61,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if(!restoreSeq.getSequence().getOptions().get("owner").equals(seq.getOptions().get("owner"))) { if(seq.getOptions().get("blocking_table") != null){ - String tableName = DBAdapterPostgres.escapeNameIfNeeded(seq.getOptions().get("blocking_table").getData()); + String tableName = adapter.escapeNameIfNeeded(seq.getOptions().get("blocking_table").getData()); query+="alter table "+tableName+ " owner to "+restoreSeq.getSequence().getOptions().get("owner")+";\n"; } query+="alter sequence "+sequence+" owner to "+restoreSeq.getSequence().getOptions().get("owner")+";\n"; @@ -128,7 +128,7 @@ public void removeMetaObject(IMetaObject obj) throws Exception { if (seq == null) return; String schema = getPhisicalSchema(seq.getSchema()); - st.execute("DROP SEQUENCE IF EXISTS "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(seq.getName())); + st.execute("DROP SEQUENCE IF EXISTS "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(seq.getName())); } catch (Exception e) { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index 0f3dd66..34d856c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -146,7 +146,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa try (StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql())) { String schema = getPhisicalSchema(restoreTableData.getTable().getSchema()); - String tblNameEscaped = DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(restoreTableData.getTable().getName()); + String tblNameEscaped = adapter.escapeNameIfNeeded(schema) + "." + adapter.escapeNameIfNeeded(restoreTableData.getTable().getName()); String fields = getFieldsPrefix(restoreTableData); Map colTypes = getColumnDataTypes(restoreTableData.getMetaTable(), st); Set keyNames = restoreTableData.getMetaTable().getFields().values().stream() @@ -552,7 +552,7 @@ private String getFieldsPrefix(MetaTableData restoreTableData) throws ExceptionD return MessageFormat.format("({0}) values " , restoreTableData.getMetaTableFromFile().getFields().entrySet().stream() .sorted(Comparator.comparing(e -> e.getValue().getOrder())) - .map(entry -> DBAdapterPostgres.escapeNameIfNeeded(entry.getValue().getName())) + .map(entry -> adapter.escapeNameIfNeeded(entry.getValue().getName())) .collect(Collectors.joining(", ")) ); } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index b838623..58c912f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -68,7 +68,7 @@ public void removeMetaObject(IMetaObject obj) throws Exception { String schema = getPhisicalSchema(tbl.getSchema()); freeTableSequences(tbl, connect, st); - st.execute("DROP TABLE "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(tbl.getName())); + st.execute("DROP TABLE "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(tbl.getName())); } catch (Exception e) { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); @@ -86,9 +86,9 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception { MetaTable restoreTable = (MetaTable)obj; MetaTable existingTable = new MetaTable(restoreTable.getTable()); - String schema = DBAdapterPostgres.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase())); - String tblName = DBAdapterPostgres.escapeNameIfNeeded(restoreTable.getTable().getName()); - String tblSam = DBAdapterPostgres.escapeNameIfNeeded(schema) + "." + DBAdapterPostgres.escapeNameIfNeeded(tblName); + String schema = adapter.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase())); + String tblName = adapter.escapeNameIfNeeded(restoreTable.getTable().getName()); + String tblSam = adapter.escapeNameIfNeeded(schema) + "." + adapter.escapeNameIfNeeded(tblName); ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTable").withParams(schema+"."+tblName), 1); @@ -148,8 +148,8 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { for(DBIndex ind:diffInd.entriesOnlyOnRight().values()) { if(existingTable.getConstraints().containsKey(ind.getName())) continue; st.execute(MessageFormat.format("drop index if exists {0}.{1}" - , DBAdapterPostgres.escapeNameIfNeeded(schema) - , DBAdapterPostgres.escapeNameIfNeeded(ind.getName()) + , adapter.escapeNameIfNeeded(schema) + , adapter.escapeNameIfNeeded(ind.getName()) )); } @@ -159,14 +159,14 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { if(!restoreIndex.getSql().equalsIgnoreCase(existingIndex.getSql())) { st.execute(MessageFormat.format( "DROP INDEX {0}.{1} CASCADE;\n" + "{2};\n", //TODO discuss CASCADE - DBAdapterPostgres.escapeNameIfNeeded(schema) - , DBAdapterPostgres.escapeNameIfNeeded(existingIndex.getName()) + adapter.escapeNameIfNeeded(schema) + , adapter.escapeNameIfNeeded(existingIndex.getName()) , restoreIndex.getSql() //drop and re-create using full DDL from .getSql() )); st.execute(MessageFormat.format( "alter index {0}.{1} set tablespace {2}" - ,DBAdapterPostgres.escapeNameIfNeeded(schema) - ,DBAdapterPostgres.escapeNameIfNeeded(restoreIndex.getName()) + ,adapter.escapeNameIfNeeded(schema) + ,adapter.escapeNameIfNeeded(restoreIndex.getName()) ,restoreIndex.getOptions().getChildren().containsKey("tablespace") ? restoreIndex.getOptions().get("tablespace").getData() : "pg_default" @@ -209,9 +209,9 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { for(DBConstraint constr : diff.entriesOnlyOnLeft().values()){ st.execute(MessageFormat.format( "alter table {0}.{1} drop constraint {2};\n" - , DBAdapterPostgres.escapeNameIfNeeded(schema) - , DBAdapterPostgres.escapeNameIfNeeded(existingTable.getTable().getName()) - , DBAdapterPostgres.escapeNameIfNeeded(constr.getName()) + , adapter.escapeNameIfNeeded(schema) + , adapter.escapeNameIfNeeded(existingTable.getTable().getName()) + , adapter.escapeNameIfNeeded(constr.getName()) )); } @@ -246,8 +246,8 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { } private NameMeta getEscapedNameMeta(MetaTable table) throws ExceptionDBGit { NameMeta nm = new NameMeta(); - String schema = DBAdapterPostgres.escapeNameIfNeeded(getPhisicalSchema(table.getTable().getSchema().toLowerCase())); - String tblName = DBAdapterPostgres.escapeNameIfNeeded(table.getTable().getName()); + String schema = adapter.escapeNameIfNeeded(getPhisicalSchema(table.getTable().getSchema().toLowerCase())); + String tblName = adapter.escapeNameIfNeeded(table.getTable().getName()); nm.setSchema(schema); nm.setName(tblName); @@ -319,8 +319,8 @@ && hasNotTypeSql(tblField, "text") // st.execute( // "alter table " // + tblSam - // +" rename column "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.rightValue().getName()) - // +" to "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + // +" rename column "+ adapter.escapeNameIfNeeded(tblField.rightValue().getName()) + // +" to "+ adapter.escapeNameIfNeeded(tblField.leftValue().getName()) // ); } } @@ -358,8 +358,8 @@ private void createTable(StatementLogging st, MetaTable restoreTable) throws SQL st.execute(createTableDdl); } private void restoreTableOwner(StatementLogging st, MetaTable restoreTable, MetaTable existingTable) throws SQLException, ExceptionDBGit { - String schema = DBAdapterPostgres.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase())); - String tblName = DBAdapterPostgres.escapeNameIfNeeded(restoreTable.getTable().getName()); + String schema = adapter.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase())); + String tblName = adapter.escapeNameIfNeeded(restoreTable.getTable().getName()); StringProperties exOwner= existingTable.getTable().getOptions().get("owner"); StringProperties restoreOwner = restoreTable.getTable().getOptions().get("owner"); @@ -428,8 +428,8 @@ private void restoreTableComment(MetaTable restoreTable, MetaTable existingTable if(commentsDiffer){ st.execute(MessageFormat.format( "COMMENT ON TABLE {0}.{1} IS ''{2}''" - ,DBAdapterPostgres.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema())) - ,DBAdapterPostgres.escapeNameIfNeeded(restoreTable.getTable().getName()) + ,adapter.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema())) + ,adapter.escapeNameIfNeeded(restoreTable.getTable().getName()) ,restoreTableComment )); } @@ -458,7 +458,7 @@ private void restoreTablePartition(MetaTable restoreTable, Statement st) throws private void createConstraint(MetaTable restoreTable, DBConstraint constr, StatementLogging st, boolean replaceExisting) throws Exception { NameMeta nme = getEscapedNameMeta(restoreTable); String tblSam = nme.getSchema()+"."+nme.getName(); - String constrName = DBAdapterPostgres.escapeNameIfNeeded(constr.getName()); + String constrName = adapter.escapeNameIfNeeded(constr.getName()); String constrDdl = (replaceExisting) ? MessageFormat.format("alter table {0} drop constraint {1};\n", tblSam, constrName) : ""; constrDdl += MessageFormat.format( "alter table {0} add constraint {1} {2};\n" @@ -477,7 +477,7 @@ private void createConstraint(MetaTable restoreTable, DBConstraint constr, State //TODO restoreTableFields private void addColumn(String tblSam, DBTableField tblField, Statement st ) throws SQLException { - String fieldName = DBAdapterPostgres.escapeNameIfNeeded(tblField.getName()); + String fieldName = adapter.escapeNameIfNeeded(tblField.getName()); st.execute( "alter table "+ tblSam +" add column " + fieldName + " " @@ -507,7 +507,7 @@ private void addColumn(String tblSam, DBTableField tblField, Statement st ) thro } private void dropColumn(String tblSam, DBTableField tblField, Statement st) throws SQLException { - st.execute("alter table "+ tblSam +" drop column "+ DBAdapterPostgres.escapeNameIfNeeded(tblField.getName())); + st.execute("alter table "+ tblSam +" drop column "+ adapter.escapeNameIfNeeded(tblField.getName())); } private boolean isSameTypeSql(DBTableField left, DBTableField right){ return left.getTypeSQL().equals(right.getTypeSQL()); @@ -521,16 +521,16 @@ private void alterTypeColumn(String tblSam, ValueDifference tblFie { st.execute(MessageFormat.format("ALTER TABLE {0} ALTER COLUMN {1} TYPE {2} USING ({3}::{4})" , tblSam - , DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + , adapter.escapeNameIfNeeded(tblField.leftValue().getName()) , tblField.leftValue().getTypeSQL().replace("NOT NULL", "") - , DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + , adapter.escapeNameIfNeeded(tblField.leftValue().getName()) , tblField.leftValue().getTypeSQL().replace("NOT NULL", "") )); if (!tblField.leftValue().getIsNullable()) { st.execute(MessageFormat.format("ALTER TABLE {0} ALTER COLUMN {1} SET NOT NULL" , tblSam - , DBAdapterPostgres.escapeNameIfNeeded(tblField.leftValue().getName()) + , adapter.escapeNameIfNeeded(tblField.leftValue().getName()) )); } } @@ -548,7 +548,7 @@ private void restoreTableFieldComment(String tableSam, ValueDifference constraints = dbTable.getConstraints(); for(DBConstraint constrs :constraints.values()) { st.execute( - "alter table "+ DBAdapterPostgres.escapeNameIfNeeded(schema) +"."+DBAdapterPostgres.escapeNameIfNeeded(table.getTable().getName()) - +" drop constraint if exists "+DBAdapterPostgres.escapeNameIfNeeded(constrs.getName()) + "alter table "+ adapter.escapeNameIfNeeded(schema) +"."+adapter.escapeNameIfNeeded(table.getTable().getName()) + +" drop constraint if exists "+adapter.escapeNameIfNeeded(constrs.getName()) ); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java index fe7ba11..d09abac 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java @@ -87,7 +87,7 @@ public void removeMetaObject(IMetaObject obj) throws Exception { if (trg == null) return; String schema = getPhisicalSchema(trg.getSchema()); - st.execute("DROP FUNCTION IF EXISTS "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(trg.getName())); + st.execute("DROP FUNCTION IF EXISTS "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(trg.getName())); } catch (Exception e) { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java index 7010c66..77161ed 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java @@ -75,7 +75,7 @@ public void removeMetaObject(IMetaObject obj) throws Exception { if (vw == null) return; String schema = getPhisicalSchema(vw.getSchema()); - st.execute("DROP VIEW "+DBAdapterPostgres.escapeNameIfNeeded(schema)+"."+DBAdapterPostgres.escapeNameIfNeeded(vw.getName())); + st.execute("DROP VIEW "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(vw.getName())); } catch (Exception e) { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); @@ -88,7 +88,7 @@ private String getDdlEscaped(MetaView view){ String name = view.getSqlObject().getName(); String schema = view.getSqlObject().getSchema(); String query = view.getSqlObject().getSql(); - String nameEscaped = DBAdapterPostgres.escapeNameIfNeeded(name); + String nameEscaped = adapter.escapeNameIfNeeded(name); if (!name.equalsIgnoreCase(nameEscaped)) { query = query.replace( @@ -104,7 +104,7 @@ private String getDdlEscaped(MetaView view){ private String getChangeOwnerDdl(MetaView view, String owner){ return MessageFormat.format("ALTER VIEW {0}.{1} OWNER TO {2}\n" , view.getSqlObject().getSchema() - , DBAdapterPostgres.escapeNameIfNeeded(view.getSqlObject().getName()) + , adapter.escapeNameIfNeeded(view.getSqlObject().getName()) , owner ); } diff --git a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java index 7d27d5f..8462f03 100644 --- a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java @@ -17,6 +17,9 @@ import static org.junit.jupiter.api.Assertions.*; import org.postgresql.jdbc.PgConnection; +import ru.fusionsoft.dbgit.adapters.AdapterFactory; +import ru.fusionsoft.dbgit.adapters.DBAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.command.*; import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.meta.IMapMetaObject; @@ -29,6 +32,7 @@ import java.nio.file.Path; import java.sql.Connection; import java.sql.DriverManager; +import java.sql.Statement; import java.text.MessageFormat; import java.util.*; @@ -56,10 +60,22 @@ public class DBGitTest { static String repoUrl = "https://github.com/rocket-3/dbgit-test.git"; static String repoBranch = "master"; - static String pgTestDbUrl = "jdbc:postgresql://localhost/"; - static String pgTestDbUser = "postgres"; - static String pgTestDbPass = "pass"; - static String pgTestDbCatalog = "testDatabasegit"; + static String pgTestDbUrl = "jdbc:postgresql://0.0.0.0/"; + static String pgTestDbUser = /*"postgres";*/"testuser"; + static String pgTestDbPass = /*"pass";*/"s%G351as"; + static String pgTestDbCatalog = "testdatabasegit"; + static boolean eraseExistingCatalog = false; + static{ if(!eraseExistingCatalog) addCatalogToUrl(); } + + private static void addCatalogToUrl() { + pgTestDbUrl = MessageFormat.format( + "{0}{1}{2}", + pgTestDbUrl, + !pgTestDbUrl.endsWith("/") ? "/" : "", + pgTestDbCatalog + ); + } + static List commitNumbers = new ArrayList<>(); //Now commit numbers are loaded automaticvally /*Arrays.asList( @@ -79,28 +95,13 @@ public class DBGitTest { @BeforeAll public static void setUp() throws Exception { - DBGit.initUrlInstance(resourcesRepoGitDirectory.toString()); + DBGit.initUrlInstance(resourcesRepoGitDirectory.toString(), false); if(commitNumbers.isEmpty()){ loadCommitNumbersFromRepo(); } - configureTestDb(); - } - - private static void loadCommitNumbersFromRepo() throws GitAPIException, IOException { - DfsRepositoryDescription repoDesc = new DfsRepositoryDescription(); - InMemoryRepository repo = new InMemoryRepository(repoDesc); - Git git = new Git(repo); - git.fetch() - .setRemote(repoUrl) - .setRefSpecs(new RefSpec("+refs/heads/"+repoBranch+":refs/heads/"+repoBranch)) - .call(); - - String treeName = "refs/heads/"+repoBranch; // tag or branch - for (RevCommit commit : git.log().add(repo.resolve(treeName)).call()) { - commitNumbers.add(commit.getName()); - } + configureTestDb(false); } @BeforeEach @@ -325,7 +326,7 @@ private static void dbgitRestore(boolean isRestore, boolean isToMakeBackup, Stri cmd.execute(builder.build()); } - private static void configureTestDb() throws Exception { + private static void configureTestDb(boolean eraseDatabase) throws Exception { String propDbUrl = System.getProperty("pgTestDbUrl"); String propDbUser = System.getProperty("pgTestDbUser"); String propDbPass = System.getProperty("pgTestDbPass"); @@ -342,21 +343,34 @@ private static void configureTestDb() throws Exception { pgTestDbProps.put("password", pgTestDbPass); } try (Connection conn = DriverManager.getConnection(pgTestDbUrl, pgTestDbProps)) { - if (!conn.getCatalog().isEmpty()) { - throw new Exception("Catalog must not be specified to create test database."); + + if(eraseDatabase){ + if (!conn.getCatalog().isEmpty()) { + throw new Exception("Catalog must not be specified to create test database."); + } + + IDBAdapter adapter = AdapterFactory.createAdapter(); + + try(Statement stmt = conn.createStatement()){ + stmt.execute(MessageFormat.format( + "DROP DATABASE {0}; ", + AdapterFactory.createAdapter().escapeNameIfNeeded(pgTestDbCatalog) + )); + } catch (Exception ex){ ConsoleWriter.println("### failed to drop database: " + ex.getLocalizedMessage()); } + + try(Statement stmt = conn.createStatement()){ + stmt.execute(MessageFormat.format( + "CREATE DATABASE {0} ENCODING = 'UTF8'", + adapter.escapeNameIfNeeded(pgTestDbCatalog) + )); + } catch (Exception ex){ + ConsoleWriter.println("### failed to create database: " + ex.getLocalizedMessage()); + throw ex; + } + + addCatalogToUrl(); } - conn.createStatement().execute(MessageFormat.format( - "DROP DATABASE IF EXISTS {0}; " + - "CREATE DATABASE {0} ENCODING = 'UTF8'", - DBAdapterPostgres.escapeNameIfNeeded(pgTestDbCatalog) - )); - pgTestDbUrl = MessageFormat.format( - "{0}{1}{2}", - pgTestDbUrl, - !pgTestDbUrl.endsWith("/") ? "/" : "", - pgTestDbCatalog - ); } DBConnection.createFileDBLink(pgTestDbUrl, pgTestDbProps, false); @@ -364,6 +378,21 @@ private static void configureTestDb() throws Exception { } + private static void loadCommitNumbersFromRepo() throws GitAPIException, IOException { + DfsRepositoryDescription repoDesc = new DfsRepositoryDescription(); + InMemoryRepository repo = new InMemoryRepository(repoDesc); + Git git = new Git(repo); + git.fetch() + .setRemote(repoUrl) + .setRefSpecs(new RefSpec("+refs/heads/"+repoBranch+":refs/heads/"+repoBranch)) + .call(); + + String treeName = "refs/heads/"+repoBranch; // tag or branch + for (RevCommit commit : git.log().add(repo.resolve(treeName)).call()) { + commitNumbers.add(commit.getName()); + } + } + private static void restoreDbLinkIfNeeded() throws Exception { String urlWas = DBConnection.loadFileDBLink(new Properties()); if(pgTestDbConnection == null || !urlWas.equals(pgTestDbUrl)){ From a06f854d6a8949b510edbd3cdcb7cfc612f9174b Mon Sep 17 00:00:00 2001 From: rocket Date: Tue, 24 Nov 2020 00:46:27 +0300 Subject: [PATCH 36/68] IMetaObject and database version and backward compatibility workaround + DBAdapter.tryConvert fix error with native fields on same db type + IDBAdapter.getDbVersionNumber, IMetaObject.getDbVersionNumber methods allow comparison + FactoryDbConvertAdapterPostgres add converter to fix convert error with different db and metaObject versions + DBAdapterPostgres add compatibility with pg version >= 9.3 --- .../fusionsoft/dbgit/adapters/DBAdapter.java | 26 +- .../dbgit/adapters/DBAdapterProxy.java | 5 + .../fusionsoft/dbgit/adapters/IDBAdapter.java | 3 +- .../ru/fusionsoft/dbgit/meta/IMetaObject.java | 4 +- .../ru/fusionsoft/dbgit/meta/MetaBase.java | 284 +++++++++--------- .../dbgit/postgres/DBAdapterPostgres.java | 150 +++++---- .../postgres/DBRestoreTablePostgres.java | 2 +- .../FactoryDbConvertAdapterPostgres.java | 6 + .../BypassVersionConverterPostgresql.java | 24 ++ 9 files changed, 304 insertions(+), 200 deletions(-) create mode 100644 src/main/java/ru/fusionsoft/dbgit/postgres/converters/BypassVersionConverterPostgresql.java diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 4e01397..5a7e87b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -18,6 +18,8 @@ import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import java.util.stream.Collectors; /** @@ -188,19 +190,22 @@ public String cleanString(String str) { private IMetaObject tryConvert(IMetaObject obj) throws Exception { if ( obj.getDbType() == null) throw new Exception(lang.getValue("errors", "emptyDbType").toString()); - if ( isSameDbType(obj) && isSameDbVersion(obj)) return obj; - - if ( checkContainsNativeFields(obj)) { - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "restore", "unsupportedTypes").withParams(obj.getName())); - return obj; + if (isSameDbType(obj) ){ + if(isSameDbVersion(obj) || obj.getDbVersionNumber() <= getDbVersionNumber()){ + return obj; + } + } else { + if ( checkContainsNativeFields(obj)) { + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "restore", "unsupportedTypes").withParams(obj.getName())); + } } IDBConvertAdapter convertAdapter = getConvertAdapterFactory().getConvertAdapter(obj.getType().getValue()); if (convertAdapter != null) return convertAdapter.convert(getDbType(), getDbVersion(), obj); else { throw new Exception(MessageFormat.format( - "Could not get convert adapter for {0} ({1} {2})", - obj.getName(), obj.getDbType().toString(), obj.getDbVersion() + "Could not get convert adapter for {0} ({1} {2} -> {3})", + obj.getName(), obj.getDbType().toString(), obj.getDbVersion(), getDbVersionNumber() )); } } @@ -282,11 +287,16 @@ private String getSchemaSynonymName(String schemaName) throws Exception { private String getSchemaSynonymName(IMetaObject obj) throws Exception { return getSchemaSynonymName(getSchemaName(obj)); } + public Double getDbVersionNumber(){ + Matcher matcher = Pattern.compile("\\D*(\\d+)\\.(\\d+)").matcher(getDbVersion()); + matcher.find(); + Double result = Double.valueOf(matcher.group(0)+matcher.group(1)); + return result; + } private boolean isSameDbType(IMetaObject obj){ return obj.getDbType().equals(getDbType()); } private boolean isSameDbVersion(IMetaObject obj){ - if(getDbVersion().equals("13.0 (Ubuntu 13.0-1.pgdg18.04+1)")) return true; //temp hack to run on remote test db return obj.getDbVersion().equals(getDbVersion()); } diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java index dac47e2..6e0ecc6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java @@ -227,6 +227,11 @@ public String getDbVersion() { return adapter.getDbVersion(); } + @Override + public Double getDbVersionNumber() { + return adapter.getDbVersionNumber(); + } + @Override public IFactoryDBConvertAdapter getConvertAdapterFactory() { return adapter.getConvertAdapterFactory(); diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java index 7cb4039..bf805b4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java @@ -149,7 +149,8 @@ public interface IDBAdapter { public IFactoryDBConvertAdapter getConvertAdapterFactory(); public DbType getDbType(); - public String getDbVersion(); + public String getDbVersion(); + public Double getDbVersionNumber(); public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit; public void createRoleIfNeed(String roleName) throws ExceptionDBGit; diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java index 761a8cb..3085da3 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java @@ -55,7 +55,9 @@ public interface IMetaObject { public void setDbType(DbType dbType); public String getDbVersion(); - + + public Double getDbVersionNumber(); + public void setDbVersion(String dbVersion); public String getFileName(); diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java index 03d33e3..4b6e70d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java @@ -1,137 +1,147 @@ -package ru.fusionsoft.dbgit.meta; - -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.nio.charset.Charset; - -import org.yaml.snakeyaml.DumperOptions; -import org.yaml.snakeyaml.Yaml; -import org.yaml.snakeyaml.DumperOptions.ScalarStyle; -import org.yaml.snakeyaml.nodes.Tag; - -import ru.fusionsoft.dbgit.adapters.AdapterFactory; -import ru.fusionsoft.dbgit.core.DBGit; -import ru.fusionsoft.dbgit.core.DBGitPath; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; -import ru.fusionsoft.dbgit.core.db.DbType; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import ru.fusionsoft.dbgit.yaml.DBGitYamlConstructor; -import ru.fusionsoft.dbgit.yaml.DBGitYamlRepresenter; -import ru.fusionsoft.dbgit.yaml.YamlOrder; - - -/** - * Base class for all meta objects - * @author mikle - * - */ -public abstract class MetaBase implements IMetaObject { - @YamlOrder(0) - protected String name; - - @YamlOrder(1) - protected DbType dbType; - - @YamlOrder(1) - protected String dbVersion; - - @Override - public String getName() { - return name; - } - - @Override - public void setDbType(DbType dbType) { - this.dbType = dbType; - } - - @Override - public DbType getDbType() { - return dbType; - } - - @Override - public void setDbVersion(String dbVersion) { - this.dbVersion = dbVersion; - } - - @Override - public String getDbVersion() { - return dbVersion; - } - - @Override - public void setName(String name) throws ExceptionDBGit { - this.name = name; - } - - @Override - public String getFileName() { - return getName(); - } - - /** - *
When you save the yaml object, the library ignores properties for which there is no getter and setter
- *
При сохранении объекта yaml библиотека игнорирует свойства для которых нет геттера и сеттера
- * @param stream - * @throws IOException - */ - public boolean yamlSerialize(OutputStream stream) throws IOException { - Yaml yaml = createYaml(); - String output = yaml.dumpAs(this, Tag.MAP, DumperOptions.FlowStyle.BLOCK); - - stream.write(output.getBytes(Charset.forName("UTF-8"))); - return true; - } - - public IMetaObject yamlDeSerialize(InputStream stream) { - Yaml yaml = createYaml(); - - IMetaObject meta = yaml.loadAs(stream, this.getClass()); - return meta; - } - - public Yaml createYaml() { - DumperOptions options = new DumperOptions(); - options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK); - options.setPrettyFlow(true); - Yaml yaml = new Yaml(new DBGitYamlConstructor(), new DBGitYamlRepresenter(), options); - return yaml; - } - - @Override - public int addToGit() throws ExceptionDBGit { - DBGit dbGit = DBGit.getInstance(); - dbGit.addFileToIndexGit(DBGitPath.DB_GIT_PATH+"/"+getFileName()); - return 1; - } - - @Override - public int removeFromGit() throws ExceptionDBGit { - DBGit dbGit = DBGit.getInstance(); - dbGit.removeFileFromIndexGit(DBGitPath.DB_GIT_PATH+"/"+getFileName()); - return 1; - } - - public void setDbType() { - try { - setDbType(AdapterFactory.createAdapter().getDbType()); - } catch (ExceptionDBGit e) { - throw new ExceptionDBGitRunTime(e.getLocalizedMessage()); - } - - } - - public void setDbVersion() { - try { - setDbVersion(AdapterFactory.createAdapter().getDbVersion()); - } catch (ExceptionDBGit e) { - throw new ExceptionDBGitRunTime(e.getLocalizedMessage()); - } - - } - - -} +package ru.fusionsoft.dbgit.meta; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.nio.charset.Charset; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.yaml.snakeyaml.DumperOptions; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.DumperOptions.ScalarStyle; +import org.yaml.snakeyaml.nodes.Tag; + +import ru.fusionsoft.dbgit.adapters.AdapterFactory; +import ru.fusionsoft.dbgit.core.DBGit; +import ru.fusionsoft.dbgit.core.DBGitPath; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; +import ru.fusionsoft.dbgit.core.db.DbType; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.yaml.DBGitYamlConstructor; +import ru.fusionsoft.dbgit.yaml.DBGitYamlRepresenter; +import ru.fusionsoft.dbgit.yaml.YamlOrder; + + +/** + * Base class for all meta objects + * @author mikle + * + */ +public abstract class MetaBase implements IMetaObject { + @YamlOrder(0) + protected String name; + + @YamlOrder(1) + protected DbType dbType; + + @YamlOrder(1) + protected String dbVersion; + + @Override + public String getName() { + return name; + } + + @Override + public void setDbType(DbType dbType) { + this.dbType = dbType; + } + + @Override + public DbType getDbType() { + return dbType; + } + + @Override + public void setDbVersion(String dbVersion) { + this.dbVersion = dbVersion; + } + + @Override + public String getDbVersion() { + return dbVersion; + } + + @Override + public Double getDbVersionNumber() { + Matcher matcher = Pattern.compile("\\D*(\\d+)\\.(\\d+)").matcher(getDbVersion()); + matcher.find(); + Double result = Double.valueOf(matcher.group(0)+matcher.group(1)); + return result; + } + + @Override + public void setName(String name) throws ExceptionDBGit { + this.name = name; + } + + @Override + public String getFileName() { + return getName(); + } + + /** + *
When you save the yaml object, the library ignores properties for which there is no getter and setter
+ *
При сохранении объекта yaml библиотека игнорирует свойства для которых нет геттера и сеттера
+ * @param stream + * @throws IOException + */ + public boolean yamlSerialize(OutputStream stream) throws IOException { + Yaml yaml = createYaml(); + String output = yaml.dumpAs(this, Tag.MAP, DumperOptions.FlowStyle.BLOCK); + + stream.write(output.getBytes(Charset.forName("UTF-8"))); + return true; + } + + public IMetaObject yamlDeSerialize(InputStream stream) { + Yaml yaml = createYaml(); + + IMetaObject meta = yaml.loadAs(stream, this.getClass()); + return meta; + } + + public Yaml createYaml() { + DumperOptions options = new DumperOptions(); + options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK); + options.setPrettyFlow(true); + Yaml yaml = new Yaml(new DBGitYamlConstructor(), new DBGitYamlRepresenter(), options); + return yaml; + } + + @Override + public int addToGit() throws ExceptionDBGit { + DBGit dbGit = DBGit.getInstance(); + dbGit.addFileToIndexGit(DBGitPath.DB_GIT_PATH+"/"+getFileName()); + return 1; + } + + @Override + public int removeFromGit() throws ExceptionDBGit { + DBGit dbGit = DBGit.getInstance(); + dbGit.removeFileFromIndexGit(DBGitPath.DB_GIT_PATH+"/"+getFileName()); + return 1; + } + + public void setDbType() { + try { + setDbType(AdapterFactory.createAdapter().getDbType()); + } catch (ExceptionDBGit e) { + throw new ExceptionDBGitRunTime(e.getLocalizedMessage()); + } + + } + + public void setDbVersion() { + try { + setDbVersion(AdapterFactory.createAdapter().getDbVersion()); + } catch (ExceptionDBGit e) { + throw new ExceptionDBGitRunTime(e.getLocalizedMessage()); + } + + } + + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index a178929..7203031 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -199,30 +199,42 @@ public DBSequence getSequence(String schema, String name) { public Map getTables(String schema) { Map listTable = new HashMap(); try { + + String query = - "select \n" + + "SELECT \n" + " tablename AS table_name,\n" + " tableowner AS owner,\n" + - " tablespace,hasindexes,hasrules,hastriggers, \n" + - " obj_description(to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid) AS table_comment, " + + " tablespace, hasindexes, hasrules, hastriggers, \n" + + " obj_description( (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment,\n" + " ( " + " SELECT array_agg( distinct n2.nspname || '/' || c2.relname || '.tbl' ) AS dependencies\n" + " FROM pg_catalog.pg_constraint c \n" + " JOIN ONLY pg_catalog.pg_class c1 ON c1.oid = c.conrelid\n" + " JOIN ONLY pg_catalog.pg_class c2 ON c2.oid = c.confrelid\n" + " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + - " WHERE c.conrelid = to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid\n" + + " WHERE c.conrelid = (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid\n" + " and c1.relkind = 'r' AND c.contype = 'f'\n" + - " ) AS dependencies, \n" + - " pg_get_partkeydef((SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"'))) " + - " AS partkeydef, \n" + - " parent.relname AS parent, \n" + - " pg_get_expr(child.relpartbound, child.oid) AS pg_get_expr \n" + - "from pg_tables \n" + - "left outer join pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) = pg_inherits.inhrelid \n" + - "left outer JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + - "left outer JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + - "where upper(schemaname) = upper(:schema)"; + " ) " + + " AS dependencies, \n" + + ( (getDbVersionNumber() > 10) + ? " pg_get_partkeydef((" + + " SELECT oid " + + " FROM pg_class " + + " WHERE relname = tablename " + + " AND relnamespace = (select oid from pg_namespace where nspname = :schema" + + " )) " + + " AS partkeydef, \n" + + " pg_get_expr(child.relpartbound, child.oid) " + + " AS pg_get_expr, \n" + : " " + ) + + " parent.relname AS parent \n" + + "FROM pg_tables \n" + + "LEFT OUTER JOIN pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) = pg_inherits.inhrelid \n" + + "LEFT OUTER JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + + "LEFT OUTER JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + + "WHERE upper(schemaname) = upper(:schema)"; Connection connect = getConnection(); NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); @@ -255,36 +267,49 @@ public Map getTables(String schema) { @Override public DBTable getTable(String schema, String name) { String query = - "select \n" + - " tablename as table_name,\n" + - " tableowner as owner,\n" + - " tablespace,hasindexes,hasrules,hastriggers, \n" + - " obj_description(to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid) table_comment, ( \n" + - " select array_agg(distinct n2.nspname || '/' || c2.relname || '.tbl') as dependencies\n" + - " FROM pg_catalog.pg_constraint c \n" + - " JOIN ONLY pg_catalog.pg_class c1 ON c1.oid = c.conrelid\n" + - " JOIN ONLY pg_catalog.pg_class c2 ON c2.oid = c.confrelid\n" + - " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + - " WHERE c.conrelid = to_regclass('\"' || schemaname || '\".\"' || tablename || '\"')::oid\n" + - " and c1.relkind = 'r' AND c.contype = 'f'\n" + - " ) AS dependencies, \n" + - " pg_get_partkeydef((SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"'))) " + - " AS partkeydef, \n" + - " parent.relname AS parent, \n" + - " pg_get_expr(child.relpartbound, child.oid) AS pg_get_expr\n" + - "from pg_tables \n" + - "left outer join pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = '"+schema+"')) = pg_inherits.inhrelid \n" + - "left outer JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + - "left outer JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + - "where upper(schemaname) = upper('"+schema+"') \n" + - "and tablename = '"+name+"'\n"; + "SELECT \n" + + " tablename AS table_name,\n" + + " tableowner AS owner,\n" + + " tablespace, hasindexes, hasrules, hastriggers, \n" + + " obj_description( (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment, " + + " ( " + + " SELECT array_agg( distinct n2.nspname || '/' || c2.relname || '.tbl' ) AS dependencies\n" + + " FROM pg_catalog.pg_constraint c \n" + + " JOIN ONLY pg_catalog.pg_class c1 ON c1.oid = c.conrelid\n" + + " JOIN ONLY pg_catalog.pg_class c2 ON c2.oid = c.confrelid\n" + + " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + + " WHERE c.conrelid = (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid\n" + + " and c1.relkind = 'r' AND c.contype = 'f'\n" + + " ) " + + " AS dependencies, \n" + + ( (getDbVersionNumber() > 10) + ? " pg_get_partkeydef((" + + " SELECT oid " + + " FROM pg_class " + + " WHERE relname = tablename " + + " AND relnamespace = (select oid from pg_namespace where nspname = :schema" + + " )) " + + " AS partkeydef, \n" + + " pg_get_expr(child.relpartbound, child.oid) " + + " AS pg_get_expr, \n" + : " " + ) + + " parent.relname AS parent \n" + + "FROM pg_tables \n" + + "LEFT OUTER JOIN pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) = pg_inherits.inhrelid \n" + + "LEFT OUTER JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + + "LEFT OUTER JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + + "WHERE upper(schemaname) = upper(:schema)" + + "AND tablename = :name"; try { Connection connect = getConnection(); - - Statement stmt = connect.createStatement(); - - ResultSet rs = stmt.executeQuery(query); + + NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); + stmt.setString("schema", schema); + stmt.setString("name", name); + + ResultSet rs = stmt.executeQuery(); DBTable table = null; @@ -672,7 +697,10 @@ public Map getProcedures(String schema) { "FROM pg_catalog.pg_proc p\n" + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - "WHERE p.prokind = 'p' \n" + + ( (getDbVersionNumber() > 10) + ? "WHERE p.prokind = 'p' \n" + : "WHERE 1=0 \n" + ) + " AND n.nspname not in('pg_catalog', 'information_schema')\n" + " AND n.nspname = '"+schema+"'"; @@ -707,7 +735,10 @@ public DBProcedure getProcedure(String schema, String name) { "FROM pg_catalog.pg_proc p\n" + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - "WHERE p.prokind = 'p' \n" + + ( (getDbVersionNumber() > 10) + ? "WHERE p.prokind = 'p' \n" + : "WHERE 1=0 \n" + ) + " AND n.nspname not in('pg_catalog', 'information_schema')\n" + " AND n.nspname = '"+schema+"'" + " AND p.proname = '"+name+"'"; @@ -739,9 +770,12 @@ public Map getFunctions(String schema) { "FROM pg_catalog.pg_proc p\n" + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - "WHERE p.prokind = 'f' \n" + - " AND n.nspname not in('pg_catalog', 'information_schema')\n" + - " AND n.nspname = '"+schema+"'"; + ( (getDbVersionNumber() > 10) + ? "WHERE p.prokind = 'f' \n" + : "WHERE 1=1 " + )+ + "AND n.nspname not in('pg_catalog', 'information_schema')\n" + + "AND n.nspname = '"+schema+"'"; Connection connect = getConnection(); Statement stmt = connect.createStatement(); @@ -776,9 +810,12 @@ public DBFunction getFunction(String schema, String name) { "FROM pg_catalog.pg_proc p\n" + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - "WHERE p.prokind = 'f' \n" + - " AND n.nspname not in('pg_catalog', 'information_schema')\n" + - " AND n.nspname = '"+schema+"' AND p.proname = '"+name+"'"; + ( (getDbVersionNumber() > 10) + ? "WHERE p.prokind = 'f' \n" + : "WHERE 1=1 \n" + ) + + "AND n.nspname not in('pg_catalog', 'information_schema')\n" + + "AND n.nspname = '"+schema+"' AND p.proname = '"+name+"'"; Connection connect = getConnection(); Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query); @@ -928,9 +965,18 @@ public Map getUsers() { public Map getRoles() { Map listRole = new HashMap(); try { - String query = "select *,array_to_string(array(SELECT rolname " + - "FROM pg_roles,pg_auth_members " + - "WHERE member = auth.oid and roleid=oid), ', ') as rolmemberof from pg_authid as auth where auth.rolname not like 'pg_%'"; + String query = + "SELECT r.rolname, r.rolsuper, r.rolinherit,\n" + + " r.rolcreaterole, r.rolcreatedb, r.rolcanlogin, \n" + + " r.rolreplication," + ((getDbVersionNumber() > 9.5) ? "r.rolbypassrls,\n" : "\n") + + " r.rolconnlimit, r.rolpassword, r.rolvaliduntil,\n" + + " ARRAY(SELECT b.rolname\n" + + " FROM pg_catalog.pg_auth_members m\n" + + " JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)\n" + + " WHERE m.member = r.oid) as memberof\n" + + "FROM pg_catalog.pg_roles r\n" + + "WHERE r.rolname !~ '^pg_'\n" + + "ORDER BY 1;"; Connection connect = getConnection(); Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 58c912f..73a5b3c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -140,7 +140,7 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { for(DBIndex ind:diffInd.entriesOnlyOnLeft().values()) { if(restoreTable.getConstraints().containsKey(ind.getName())) {continue;} st.execute(MessageFormat.format("{0} {1}" - ,ind.getSql().replace(" INDEX ", " INDEX IF NOT EXISTS ") + ,ind.getSql()/*.replace(" INDEX ", " INDEX IF NOT EXISTS ")*/ ,ind.getOptions().getChildren().containsKey("tablespace") ? " tablespace " + ind.getOptions().get("tablespace").getData() : "" )); } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDbConvertAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDbConvertAdapterPostgres.java index 76b6d8e..b8be656 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDbConvertAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDbConvertAdapterPostgres.java @@ -9,6 +9,7 @@ import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.meta.DBGitMetaType; import ru.fusionsoft.dbgit.oracle.converters.TableConverterOracle; +import ru.fusionsoft.dbgit.postgres.converters.BypassVersionConverterPostgresql; import ru.fusionsoft.dbgit.postgres.converters.TableConverterPostgresql; import ru.fusionsoft.dbgit.postgres.converters.TableDataConverterPostgresql; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -21,6 +22,11 @@ public class FactoryDbConvertAdapterPostgres implements IFactoryDBConvertAdapter Map aMap = new HashMap(); aMap.put(DBGitMetaType.DBGitTable.getValue(), new TableConverterPostgresql()); aMap.put(DBGitMetaType.DbGitTableData.getValue(), new TableDataConverterPostgresql()); + aMap.put(DBGitMetaType.DBGitSequence.getValue(), new BypassVersionConverterPostgresql()); +// aMap.put(DBGitMetaType.DBGit.getValue(), new BypassVersionConverterPostgresql()); +// aMap.put(DBGitMetaType.DBGit.getValue(), new BypassVersionConverterPostgresql()); +// aMap.put(DBGitMetaType.DBGit.getValue(), new BypassVersionConverterPostgresql()); +// aMap.put(DBGitMetaType.DBGit.getValue(), new BypassVersionConverterPostgresql()); converters = Collections.unmodifiableMap(aMap); } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/converters/BypassVersionConverterPostgresql.java b/src/main/java/ru/fusionsoft/dbgit/postgres/converters/BypassVersionConverterPostgresql.java new file mode 100644 index 0000000..b98b233 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/converters/BypassVersionConverterPostgresql.java @@ -0,0 +1,24 @@ +package ru.fusionsoft.dbgit.postgres.converters; + +import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.db.DbType; +import ru.fusionsoft.dbgit.meta.IMetaObject; + +import java.text.MessageFormat; + +public class BypassVersionConverterPostgresql implements IDBConvertAdapter { + @Override + public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) throws ExceptionDBGit { + DbType objDbType = obj.getDbType(); + if (dbType == objDbType){ + return obj; + } else { + throw new ExceptionDBGit(MessageFormat.format("Cannot convert {0} from other db type ({1} {2})" + , obj.getName() + , obj.getDbType() + , obj.getDbVersionNumber() + )); + } + } +} From 71ec4276558d20888b76ca2de1b03bb96ae203e0 Mon Sep 17 00:00:00 2001 From: rocket Date: Sat, 16 Jan 2021 20:11:15 +0300 Subject: [PATCH 37/68] Fix dbgit messages and lil refactor All messages are getting texts from Lang Added logback.xml and logback-test.xml, also logback.xml included in the classpath Fix messages levels so they are displayed in a tree manner based on action hierarchy Added .dblink in example folder of distribution package --- pom.xml | 17 +- .../fusionsoft/dbgit/adapters/DBAdapter.java | 31 +- .../dbgit/adapters/DBBackupAdapter.java | 33 +- .../ru/fusionsoft/dbgit/command/CmdAdd.java | 6 +- .../fusionsoft/dbgit/command/CmdCheckout.java | 232 +++++++------- .../ru/fusionsoft/dbgit/command/CmdDump.java | 6 +- .../fusionsoft/dbgit/command/CmdRestore.java | 65 ++-- .../ru/fusionsoft/dbgit/command/CmdRm.java | 9 +- .../fusionsoft/dbgit/core/DBConnection.java | 294 +++++++++--------- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 33 +- .../fusionsoft/dbgit/core/ExceptionDBGit.java | 19 +- .../dbgit/core/GitMetaDataManager.java | 5 +- .../dbgit/mssql/DBBackupAdapterMssql.java | 14 +- .../dbgit/mssql/DBRestoreFunctionMssql.java | 3 +- .../dbgit/mssql/DBRestoreProcedureMssql.java | 3 +- .../dbgit/mssql/DBRestoreRoleMssql.java | 3 +- .../dbgit/mssql/DBRestoreSchemaMssql.java | 3 +- .../dbgit/mssql/DBRestoreSequenceMssql.java | 3 +- .../dbgit/mssql/DBRestoreTableDataMssql.java | 21 +- .../dbgit/mssql/DBRestoreTableMssql.java | 38 +-- .../dbgit/mssql/DBRestoreTableSpaceMssql.java | 3 +- .../dbgit/mssql/DBRestoreTriggerMssql.java | 3 +- .../dbgit/mssql/DBRestoreUserMssql.java | 3 +- .../dbgit/mssql/DBRestoreViewMssql.java | 3 +- .../dbgit/mysql/DBBackupAdapterMySql.java | 14 +- .../dbgit/mysql/DBRestoreSchemaMySql.java | 3 +- .../dbgit/mysql/DBRestoreTableDataMySql.java | 13 +- .../dbgit/mysql/DBRestoreTableMySql.java | 25 +- .../dbgit/mysql/DBRestoreUserMySql.java | 3 +- .../dbgit/mysql/DBRestoreViewMySql.java | 3 +- .../dbgit/oracle/DBBackupAdapterOracle.java | 14 +- .../dbgit/oracle/DBRestoreFunctionOracle.java | 3 +- .../dbgit/oracle/DBRestorePackageOracle.java | 3 +- .../oracle/DBRestoreProcedureOracle.java | 5 +- .../dbgit/oracle/DBRestoreRoleOracle.java | 3 +- .../dbgit/oracle/DBRestoreSchemaOracle.java | 3 +- .../dbgit/oracle/DBRestoreSequenceOracle.java | 3 +- .../oracle/DBRestoreTableDataOracle.java | 19 +- .../dbgit/oracle/DBRestoreTableOracle.java | 29 +- .../dbgit/oracle/DBRestoreTriggerOracle.java | 5 +- .../dbgit/oracle/DBRestoreViewOracle.java | 3 +- .../postgres/DBBackupAdapterPostgres.java | 14 +- .../postgres/DBRestoreFunctionPostgres.java | 8 +- .../postgres/DBRestoreProcedurePostgres.java | 213 +++++++------ .../dbgit/postgres/DBRestoreRolePostgres.java | 3 +- .../postgres/DBRestoreSchemaPostgres.java | 131 ++++---- .../postgres/DBRestoreSequencePostgres.java | 3 +- .../postgres/DBRestoreTableDataPostgres.java | 15 +- .../postgres/DBRestoreTablePostgres.java | 39 ++- .../postgres/DBRestoreTableSpacePostgres.java | 178 +++++------ .../postgres/DBRestoreTriggerPostgres.java | 3 +- .../dbgit/postgres/DBRestoreUserPostgres.java | 3 +- .../dbgit/postgres/DBRestoreViewPostgres.java | 2 +- .../fusionsoft/dbgit/utils/ConsoleWriter.java | 62 +++- src/main/resources/lang/eng.yaml | 22 +- src/main/resources/logback.xml | 4 +- src/test/resources/logback-test.xml | 50 +++ 57 files changed, 955 insertions(+), 796 deletions(-) create mode 100644 src/test/resources/logback-test.xml diff --git a/pom.xml b/pom.xml index 3b96acb..da1f504 100644 --- a/pom.xml +++ b/pom.xml @@ -85,6 +85,12 @@ + + ${project.basedir}/src/main/resources/ + + logback.xml + + ${project.basedir}/src/main/resources/scripts ${project.build.directory}/dbgit @@ -114,8 +120,15 @@ - ${project.basedir}/src/main/resources - ${project.build.directory}/dbgit + ${project.basedir}/src/main/resources/example + ${project.build.directory}/dbgit/example + + .dblink + + + + ${project.basedir}/src/main/resources/ + ${project.build.directory}/dbgit/ dbgitconfig diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 5a7e87b..6355f4c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -1,5 +1,6 @@ package ru.fusionsoft.dbgit.adapters; +import com.diogonunes.jcdp.color.api.Ansi; import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.data_table.*; @@ -101,8 +102,9 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { Set createdRoles = getRoles().values().stream().map(DBRole::getName).collect(Collectors.toSet()); // remove table indexes and constraints, which is step(-2) of restoreMetaObject(MetaTable) - ConsoleWriter.println("Dropping constraints for all updating tables..."); + ConsoleWriter.println(lang.getValue("general", "restore", "droppingTablesConstraints"), 1); for (IMetaObject table : tablesExists.sortFromDependencies()) { + ConsoleWriter.println(lang.getValue("general", "restore", "droppingTableConstraints").withParams(table.getName()), 2); getFactoryRestore().getAdapterRestore(DBGitMetaType.DBGitTable, this).restoreMetaObject(table, -2); } @@ -120,17 +122,23 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { createSchemaIfNeed(obj, createdSchemas); while (!res) { + if(step==0) printRestoreMessage(obj); + //if(step!=0) ConsoleWriter.print(" (step " + step + ")"); res = restoreAdapter.restoreMetaObject(obj, step++); if (step > 100) { throw new Exception(lang.getValue("errors", "restore", "restoreErrorDidNotReturnTrue").toString()); } } Long timeDiff = new Timestamp(System.currentTimeMillis()).getTime() - timestampBefore.getTime(); - ConsoleWriter.detailsPrintlnGreen(MessageFormat.format("({1} {2})", obj.getName(), timeDiff, lang.getValue("general", "add", "ms"))); +// ConsoleWriter.detailsPrintColor(MessageFormat.format(" ({1} {2})" +// , obj.getName() +// , timeDiff +// , lang.getValue("general", "add", "ms")), 0, Ansi.FColor.CYAN +// ); } // restore table constraints, which is step(-1) of restoreMetaObject(MetaTable) - ConsoleWriter.println("Restoring constraints for all updated tables..."); + ConsoleWriter.println(lang.getValue("general", "restore", "restoringTablesConstraints"), 2); for (IMetaObject table : tables.sortFromReferenced()) { getFactoryRestore().getAdapterRestore(DBGitMetaType.DBGitTable, this).restoreMetaObject(table, -1); } @@ -145,6 +153,23 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { } + private void printRestoreMessage(IMetaObject obj) { + String leafName = ""; + if(obj instanceof MetaSequence){ leafName = "restoreSeq"; } + if(obj instanceof MetaView){ leafName = "restoreView"; } + if(obj instanceof MetaTrigger){ leafName = "restoreTrigger"; } + if(obj instanceof MetaSchema){ leafName = "restoreSchema"; } + if(obj instanceof MetaRole){ leafName = "restoreRole"; } + if(obj instanceof MetaProcedure){ leafName = "restorePrc"; } + if(obj instanceof MetaPackage){ leafName = "restorePkg"; } + if(obj instanceof MetaUser){ leafName = "restoreUser"; } + if(obj instanceof MetaFunction){ leafName = "restoreFnc"; } + if(obj instanceof MetaTable){ leafName = "restoreTable"; } + if(obj instanceof MetaTableSpace){ leafName = "restoreTablespace"; } + if(obj instanceof MetaTableData){ leafName = "restoreTableData"; } + ConsoleWriter.println(lang.getValue("general", "restore", leafName).withParams(obj.getName()), 2); + } + @Override public void deleteDataBase(IMapMetaObject deleteObjs) throws Exception { deleteDataBase(deleteObjs, false); diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java index c3cd975..b567e6d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java @@ -84,9 +84,13 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { .filter(this::isBackupObject) .collect(Collectors.toList())); - - - ConsoleWriter.printlnGreen(MessageFormat.format("Try to backup {0} present of {1} restoring objects ", dbToBackup.size(), updateObjs.size())); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "backup", "tryToBackup") + .withParams( + String.valueOf(dbToBackup.size()), + String.valueOf(updateObjs.size())) + , 1 + ); // collect restore objects dependencies to satisfy all backups create needs @@ -104,8 +108,12 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { dbToBackup.putAll(addedObjs); if(addedObjs.size() > 0) { - ConsoleWriter.detailsPrintlnGreen(MessageFormat.format("Found {0} depending backups: {1}" - , addedObjs.size(), String.join(" ,", addedObjs.keySet())) + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "backup", "dependingBackups") + .withParams( + String.valueOf(addedObjs.size()), + String.join(" ,", addedObjs.keySet()) + ), 2 ); } } while (addedObjs.size() > 0); @@ -129,16 +137,23 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { dropList.addAll(dbDroppingBackupsDeps); List dropListSorted = new SortedListMetaObject(dropList).sortFromDependencies(); - ConsoleWriter.printlnGreen(MessageFormat.format("Rewriting {0} backups with {1} dependencies", dbDroppingBackups.size(), dbDroppingBackupsDeps.size())); - dropListSorted.forEach( x -> ConsoleWriter.detailsPrintlnGreen( x.getName())); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "backup", "rewritingBackups") + .withParams( + String.valueOf(dbDroppingBackups.size()), + String.valueOf(dbDroppingBackupsDeps.size()) + ), 2 + ); + + //dropListSorted.forEach( x -> ConsoleWriter.detailsPrintLnColor( x.getName(), 3, Ansi.FColor.MAGENTA)); //drop backups in one place for(IMetaObject imo : dropListSorted){ - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "droppingBackup").withParams(imo.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "droppingBackup").withParams(imo.getName()), 3); dropIfExists(imo, stLog); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } //create backups diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java index 9e60cee..8b18b72 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java @@ -80,15 +80,15 @@ public void execute(CommandLine cmdLine) throws Exception { Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); ConsoleWriter.detailsPrintLn(getLang().getValue("general", "add", "processingObject") + " " + obj.getName()); - ConsoleWriter.detailsPrint(getLang().getValue("general", "add", "savingToFile"), 2); + ConsoleWriter.detailsPrintLn(getLang().getValue("general", "add", "savingToFile"), 2); //TODO obj.saveToFile(); - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); ConsoleWriter.detailsPrint(getLang().getValue("general", "addToGit"), 2); countSave += obj.addToGit(); - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); Long diff = timestampAfter.getTime() - timestampBefore.getTime(); diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java index 5577d70..f0ac2b6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java @@ -1,116 +1,116 @@ -package ru.fusionsoft.dbgit.command; - -import org.apache.commons.cli.CommandLine; -import org.apache.commons.cli.CommandLine.Builder; -import org.apache.commons.cli.Option; -import org.apache.commons.cli.Options; - -import org.eclipse.jgit.lib.Ref; -import org.eclipse.jgit.lib.Repository; -import org.eclipse.jgit.revwalk.RevWalk; -import ru.fusionsoft.dbgit.core.DBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import java.text.MessageFormat; - -public class CmdCheckout implements IDBGitCommand { - - private Options opts = new Options(); - - public CmdCheckout() { - opts.addOption("b", false, getLang().getValue("help", "checkout-b").toString()); - opts.addOption("r", false, getLang().getValue("help", "checkout-r").toString()); - opts.addOption("u", false, getLang().getValue("help", "checkout-u").toString()); - opts.addOption("nodb", false, getLang().getValue("help", "checkout-no-db").toString()); - opts.addOption("upgrade", false, getLang().getValue("help", "checkout-u").toString()); - opts.addOption("ls", false, getLang().getValue("help", "checkout-ls").toString()); - } - - @Override - public String getCommandName() { - return "checkout"; - } - - @Override - public String getParams() { - return " "; - } - - @Override - public String getHelperInfo() { - return getLang().getValue("help", "checkout").toString(); - } - - @Override - public Options getOptions() { - return opts; - } - - @Override - public void execute(CommandLine cmdLine) throws Exception { - - String[] args = cmdLine.getArgs(); - ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); - - Repository repo = DBGit.getInstance().getRepository(); - Ref head = repo.getAllRefs().get("HEAD"); - - if (cmdLine.hasOption("ls")){ - try(RevWalk walk = new RevWalk(repo)){ - String branch = repo.getBranch(); - String headNumber = head.getObjectId().getName(); - String headName = head.getName(); - String message = walk.parseCommit(head.getObjectId()).getShortMessage(); - - ConsoleWriter.printlnGreen(MessageFormat.format( - "{0} ({1}) {2}", - !branch.equals(headNumber) ? branch + ": " + headName : headNumber, - headName, - message - )); - } - return; - } - - if (!cmdLine.hasOption("u") && !cmdLine.hasOption("nodb")) - checkVersion(); - if (args == null || args.length == 0) { - throw new ExceptionDBGit(getLang().getValue("errors", "checkout", "badCommand")); - } else if (args.length == 1) { - DBGit.getInstance().gitCheckout(args[0], null, cmdLine.hasOption("b")); - } else if (args.length == 2) { - DBGit.getInstance().gitCheckout(args[0], args[1], cmdLine.hasOption("b")); - } - - Builder builder = new CommandLine.Builder(); - - if (cmdLine.hasOption("u")) { - CmdDump dumpCommand = new CmdDump(); - builder.addOption(new Option("u", false, "")); - - if (cmdLine.hasOption("v")) { - builder.addOption(new Option("v", false, "")); - } - - dumpCommand.execute(builder.build()); - } else if (!cmdLine.hasOption("nodb")) { - CmdRestore restoreCommand = new CmdRestore(); - - if (cmdLine.hasOption("r")) { - builder.addOption(new Option("r", false, "")); - } - if (cmdLine.hasOption("v")) { - builder.addOption(new Option("v", false, "")); - } - if (cmdLine.hasOption("s")) { - Option scriptOption = new Option("s", true, ""); - scriptOption.getValuesList().add(cmdLine.getOptionValue("s")); - builder.addOption(scriptOption); - } - - restoreCommand.execute(builder.build()); - } - - } - -} +package ru.fusionsoft.dbgit.command; + +import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.CommandLine.Builder; +import org.apache.commons.cli.Option; +import org.apache.commons.cli.Options; + +import org.eclipse.jgit.lib.Ref; +import org.eclipse.jgit.lib.Repository; +import org.eclipse.jgit.revwalk.RevWalk; +import ru.fusionsoft.dbgit.core.DBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import java.text.MessageFormat; + +public class CmdCheckout implements IDBGitCommand { + + private Options opts = new Options(); + + public CmdCheckout() { + opts.addOption("b", false, getLang().getValue("help", "checkout-b").toString()); + opts.addOption("r", false, getLang().getValue("help", "checkout-r").toString()); + opts.addOption("u", false, getLang().getValue("help", "checkout-u").toString()); + opts.addOption("nodb", false, getLang().getValue("help", "checkout-no-db").toString()); + opts.addOption("upgrade", false, getLang().getValue("help", "checkout-u").toString()); + opts.addOption("ls", false, getLang().getValue("help", "checkout-ls").toString()); + } + + @Override + public String getCommandName() { + return "checkout"; + } + + @Override + public String getParams() { + return " "; + } + + @Override + public String getHelperInfo() { + return getLang().getValue("help", "checkout").toString(); + } + + @Override + public Options getOptions() { + return opts; + } + + @Override + public void execute(CommandLine cmdLine) throws Exception { + + String[] args = cmdLine.getArgs(); + ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); + + Repository repo = DBGit.getInstance().getRepository(); + Ref head = repo.getAllRefs().get("HEAD"); + + if (cmdLine.hasOption("ls")){ + try(RevWalk walk = new RevWalk(repo)){ + String branch = repo.getBranch(); + String headNumber = head.getObjectId().getName(); + String headName = head.getName(); + String message = walk.parseCommit(head.getObjectId()).getShortMessage(); + + ConsoleWriter.printlnGreen(MessageFormat.format( + "{0} ({1}) {2}", + !branch.equals(headNumber) ? branch + ": " + headName : headNumber, + headName, + message + )); + } + return; + } + + if (!cmdLine.hasOption("u") && !cmdLine.hasOption("nodb")) + checkVersion(); + if (args == null || args.length == 0) { + throw new ExceptionDBGit(getLang().getValue("errors", "checkout", "badCommand")); + } else if (args.length == 1) { + DBGit.getInstance().gitCheckout(args[0], null, cmdLine.hasOption("b")); + } else if (args.length == 2) { + DBGit.getInstance().gitCheckout(args[0], args[1], cmdLine.hasOption("b")); + } + + Builder builder = new CommandLine.Builder(); + + if (cmdLine.hasOption("u")) { + CmdDump dumpCommand = new CmdDump(); + builder.addOption(new Option("u", false, "")); + + if (cmdLine.hasOption("v")) { + builder.addOption(new Option("v", false, "")); + } + + dumpCommand.execute(builder.build()); + } else if (!cmdLine.hasOption("nodb")) { + CmdRestore restoreCommand = new CmdRestore(); + + if (cmdLine.hasOption("r")) { + builder.addOption(new Option("r", false, "")); + } + if (cmdLine.hasOption("v")) { + builder.addOption(new Option("v", false, "")); + } + if (cmdLine.hasOption("s")) { + Option scriptOption = new Option("s", true, ""); + scriptOption.getValuesList().add(cmdLine.getOptionValue("s")); + builder.addOption(scriptOption); + } + + restoreCommand.execute(builder.build()); + } + + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java index 16a0b1d..a063853 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java @@ -79,15 +79,15 @@ public void execute(CommandLine cmdLine) throws Exception { ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "fSwitchFound"), 2); //сохранили файл если хеш разный obj.saveToFile(); - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "addToIndex"), 2); index.addItem(obj); - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); if (isAddToGit) { ConsoleWriter.detailsPrint(getLang().getValue("general", "addToGit"), 2); obj.addToGit(); - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); } } else { ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "hashesMatch") + "\n", 2); diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java index 179c4fc..b1a64af 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java @@ -9,6 +9,7 @@ import java.util.Map; import java.util.stream.Collectors; +import com.diogonunes.jcdp.color.api.Ansi; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.Options; @@ -51,7 +52,8 @@ public void execute(CommandLine cmdLine) throws Exception { GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); - ConsoleWriter.println(""); + ConsoleWriter.println(getLang().getValue("general", "restore", "do"), 0); + boolean toMakeChanges = cmdLine.hasOption("r"); boolean toMakeBackup = DBGitConfig.getInstance().getBoolean("core", "TO_MAKE_BACKUP", true); @@ -68,50 +70,61 @@ public void execute(CommandLine cmdLine) throws Exception { IMapMetaObject updateObjs = new TreeMapMetaObject(); IMapMetaObject deleteObjs = new TreeMapMetaObject(); - if (toMakeBackup) { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "willMakeBackup").toString()); } - if (toMakeChanges) { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "toMakeChanges").toString()); } - else { ConsoleWriter.printlnGreen(getLang().getValue("general", "restore", "notMakeChanges").withParams(autoScriptFile.getAbsolutePath())); } + if (toMakeBackup) { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "willMakeBackup").toString(), Ansi.FColor.GREEN, 1); } + if (toMakeChanges) { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "toMakeChanges").toString(), Ansi.FColor.GREEN, 1); } + else { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "notMakeChanges").withParams(autoScriptFile.getAbsolutePath()), Ansi.FColor.GREEN, 1); } //delete that not present in HEAD try { DBGitIndex index = DBGitIndex.getInctance(); DBGitIgnore ignore = DBGitIgnore.getInstance(); - ConsoleWriter.println(getLang().getValue("general", "restore", "seekingToRemove")); + ConsoleWriter.println(getLang().getValue("general", "restore", "seekingToRemove"),1); +// ConsoleWriter.print(getLang().getValue("general", "restore", "toRemove")); + for ( ItemIndex item : index.getTreeItems().values() ) { if ( ignore.matchOne(item.getName()) ) continue; + if ( item.getIsDelete() ) { + if ( !dbObjs.containsKey(item.getName()) ) { - ConsoleWriter.println(getLang().getValue("general", "restore", "notExists").withParams(item.getName())); + ConsoleWriter.println(getLang().getValue("general", "restore", "notExists").withParams(item.getName()), 2); index.removeItem(item.getName()); } else { + try { IMetaObject obj = MetaObjectFactory.createMetaObject(item.getName()); gmdm.loadFromDB(obj); if (item.getHash().equals(obj.getHash())) { deleteObjs.put(obj); - if (deleteObjs.size() == 1) ConsoleWriter.println(getLang().getValue("general", "restore", "toRemove")); - ConsoleWriter.println(" " + obj.getName()); + + ConsoleWriter.println(getLang().getValue("general", "restore", "objectToRemove").withParams(obj.getName()), 2); } } catch(ExceptionDBGit e) { - LoggerUtil.getGlobalLogger().error(getLang().getValue("errors", "restore", "cantConnect") + ": " + item.getName(), e); + throw e; + //LoggerUtil.getGlobalLogger().error(getLang().getValue("errors", "restore", "cantConnect") + ": " + item.getName(), e); } } } } + if (deleteObjs.size() == 0) ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRemove").toString(), 2); - ConsoleWriter.println(getLang().getValue("general", "restore", "seekingToRestore")); + + ConsoleWriter.println(getLang().getValue("general", "restore", "seekingToRestore"),1); for (IMetaObject obj : fileObjs.values()) { //запомнили файл если хеш разный или объекта нет if (checkNeedsRestore(obj)) { updateObjs.put(obj); - if (updateObjs.size() == 1){ - ConsoleWriter.println(getLang().getValue("general", "restore", "toRestore")); - } - ConsoleWriter.println(" " + obj.getName()); +// if (updateObjs.size() == 1){ +// ConsoleWriter.print(getLang().getValue("general", "restore", "toRestore")); +// } + ConsoleWriter.println(obj.getName(), 2); } } + if (updateObjs.size() == 0){ + ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRestore").toString(), 2); + } // to fix pk constraint re-creation error // collect other file objects that depend on update objects @@ -122,6 +135,8 @@ public void execute(CommandLine cmdLine) throws Exception { // 2. re-create all constraints in default sorted order // # steps 1,2 are in GitMetaDataManager::restoreDatabase + + ConsoleWriter.println(getLang().getValue("general", "restore", "seekingToRestoreAdditional"),1); Map affectedTables = dbObjs.values().stream().filter(excluded -> excluded instanceof MetaTable && !updateObjs.containsKey(excluded.getName()) && @@ -130,10 +145,10 @@ public void execute(CommandLine cmdLine) throws Exception { if(affectedTables.isEmpty()){ - ConsoleWriter.printlnRed("No affected tables..."); + ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRestoreAdditional"), 2); } else { - ConsoleWriter.printlnRed("Affected tables:"); - affectedTables.forEach((k,v)->ConsoleWriter.printlnRed("\t"+k)); +// ConsoleWriter.print(getLang().getValue("general", "restore", "toRestoreAdditional")); + affectedTables.forEach((k,v)->ConsoleWriter.println(k, 2)); updateObjs.putAll( affectedTables ); } @@ -146,18 +161,14 @@ public void execute(CommandLine cmdLine) throws Exception { adapter.getBackupAdapterFactory().getBackupAdapter(adapter).backupDatabase(backupObjs); } - if (deleteObjs.size() == 0){ - ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRemove")); - } else { - if (toMakeChanges) ConsoleWriter.println(getLang().getValue("general", "restore", "removing")); + if (deleteObjs.size() != 0){ + if (toMakeChanges) ConsoleWriter.println(getLang().getValue("general", "restore", "removing"),1); gmdm.deleteDataBase(deleteObjs, true); } - if (updateObjs.size() == 0){ - ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRestore")); - } + if (toMakeChanges) { - ConsoleWriter.println(getLang().getValue("general", "restore", "restoring")); + ConsoleWriter.println(getLang().getValue("general", "restore", "restoring"),1); } gmdm.restoreDataBase(updateObjs); @@ -172,10 +183,10 @@ public void execute(CommandLine cmdLine) throws Exception { File file = new File(scriptName); if (!file.exists()) { - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "restore", "scriptWillSaveTo").withParams(scriptName)); + ConsoleWriter.println(getLang().getValue("general", "restore", "scriptWillSaveTo").withParams(scriptName),1); Files.copy(autoScriptFile.toPath(), file.toPath()); } else { - ConsoleWriter.detailsPrintLn(getLang().getValue("errors", "restore", "fileAlreadyExists").withParams(scriptName)); + ConsoleWriter.println(getLang().getValue("errors", "restore", "fileAlreadyExists").withParams(scriptName),1); } } } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java index 6089d45..e9402c8 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java @@ -80,16 +80,15 @@ public void execute(CommandLine cmdLine) throws Exception { metaObject = IMetaObject.create(idxItem.getName()); } - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); ConsoleWriter.detailsPrint(getLang().getValue("general", "rm", "markingToDelete") + " ... ", 2); index.markItemToDelete(metaObject); - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); Long diff = timestampAfter.getTime() - timestampBefore.getTime(); ConsoleWriter.detailsPrint(getLang().getValue("general", "time").withParams(diff.toString()), 2); - ConsoleWriter.detailsPrintLn(""); } } if (forgetImmediately) { @@ -97,13 +96,13 @@ public void execute(CommandLine cmdLine) throws Exception { index.getTreeItems().values().stream().filter(ItemIndex::getIsDelete).collect(Collectors.toList()).forEach(x->index.getTreeItems().remove(x.getName())); index.saveDBIndex(); index.addToGit(); - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); } if (cmdLine.hasOption("db")) { ConsoleWriter.detailsPrint(getLang().getValue("general", "rm", "removingFromDb"), 2); gmdm.deleteDataBase(deleteObjs, true); - ConsoleWriter.detailsPrintlnGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); } if (countDelete > 0) { diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBConnection.java b/src/main/java/ru/fusionsoft/dbgit/core/DBConnection.java index fb714e9..a33cf79 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBConnection.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBConnection.java @@ -1,145 +1,149 @@ -package ru.fusionsoft.dbgit.core; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileWriter; -import java.sql.Connection; -import java.sql.DriverManager; -import java.util.Enumeration; -import java.util.Properties; - -import org.slf4j.Logger; - -import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import ru.fusionsoft.dbgit.utils.LoggerUtil; - -/** - * Class for real connection to Database. Load parameters connection from .dblink file - * DBConnection is Singleton - * - * @author mikle - * - */ -public class DBConnection { - private static DBConnection dbGitConnection = null; - private Connection connect = null; - private Logger logger = LoggerUtil.getLogger(this.getClass()); - private DBGitLang lang = DBGitLang.getInstance(); - - private DBConnection(Boolean isConnect) throws ExceptionDBGit { - try { - Properties props = new Properties(); - String url = loadFileDBLink(props); - - if (url != null && isConnect) { - props.put("characterEncoding", "UTF-8"); - connect = DriverManager.getConnection(url, props); - connect.setAutoCommit(false); - } - } catch(Exception e) { - logger.error(lang.getValue("errors", "connectionError").toString(), e); - throw new ExceptionDBGit(e); - } - - } - - public void flushConnection() { - dbGitConnection = null; - } - - public static DBConnection getInstance() throws ExceptionDBGit { - return getInstance(true); - } - - public static DBConnection getInstance(Boolean isConnect) throws ExceptionDBGit { - if (dbGitConnection == null) { - dbGitConnection = new DBConnection(isConnect); - } - return dbGitConnection; - } - - public Connection getConnect() throws ExceptionDBGit { - return connect; - } - - public boolean testingConnection() { - try { - Properties props = new Properties(); - String url = loadFileDBLink(props); - - Connection conTest = DriverManager.getConnection(url, props); - ConsoleWriter.printlnGreen(lang.getValue("general", "link", "connectionEstablished")); - conTest.close(); - conTest = null; - return true; - } catch(Exception e) { - ConsoleWriter.printlnRed(lang.getValue("errors", "link", "cantConnect") + ": " + e.getMessage()); - return false; - } - } - - public boolean testingConnection(String url, Properties props) { - try { - Connection conTest = DriverManager.getConnection(url, props); - ConsoleWriter.printlnGreen(lang.getValue("general", "link", "connectionEstablished")); - conTest.close(); - conTest = null; - return true; - } catch(Exception e) { - ConsoleWriter.printlnRed(lang.getValue("errors", "link", "cantConnect") + ": " + e.getMessage()); - return false; - } - } - - public static void createFileDBLink(String url, Properties props, boolean isDefault) throws ExceptionDBGit { - try{ - File file; - - if (isDefault) - file = new File(DBGitPath.getFullPath(DBGitPath.DB_LINK_DEF_FILE)); - else - file = new File(DBGitPath.getFullPath(DBGitPath.DB_LINK_FILE)); - - DBGitPath.createDir(file.getParent()); - - DBGitPath.createDefaultDbgitConfig(DBGitPath.getFullPath()); - DBGitPath.createLogDir(); - DBGitPath.createScriptsDir(); - - FileWriter writer = new FileWriter(file.getAbsolutePath()); - writer.write("url="+url+"\n"); - Enumeration e = props.propertyNames(); - - while (e.hasMoreElements()) { - String key = (String) e.nextElement(); - writer.write(key+"="+ props.getProperty(key)+"\n"); - } - writer.close(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "link", "dblinkCreated").withParams(DBGitPath.getFullPath(DBGitPath.DB_LINK_FILE))); - } catch(Exception e) { - throw new ExceptionDBGit(e); - } - } - - public static String loadFileDBLink(Properties props) throws ExceptionDBGit { - try{ - File file = new File(DBGitPath.getFullPath(DBGitPath.DB_LINK_FILE)); - File fileDef = new File(DBGitPath.getFullPath(DBGitPath.DB_LINK_DEF_FILE)); - - if (!file.exists() && !fileDef.exists()) { - return null; - } - - FileInputStream fis = new FileInputStream(file.exists() ? file : fileDef); - props.load(fis); - fis.close(); - - String url = props.getProperty("url"); - props.remove("url"); - - return url; - } catch(Exception e) { - throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "fileLoadError").withParams(DBGitPath.DB_LINK_FILE), e); - } - } -} +package ru.fusionsoft.dbgit.core; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileWriter; +import java.sql.Connection; +import java.sql.DriverManager; +import java.util.Enumeration; +import java.util.Properties; + +import org.slf4j.Logger; + +import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.utils.LoggerUtil; + +/** + * Class for real connection to Database. Load parameters connection from .dblink file + * DBConnection is Singleton + * + * @author mikle + * + */ +public class DBConnection { + private static DBConnection dbGitConnection = null; + private Connection connect = null; + private Logger logger = LoggerUtil.getLogger(this.getClass()); + private DBGitLang lang = DBGitLang.getInstance(); + + private DBConnection(Boolean isConnect) throws ExceptionDBGit { + try { + Properties props = new Properties(); + String url = loadFileDBLink(props); + + if (url != null && isConnect) { + props.put("characterEncoding", "UTF-8"); + connect = DriverManager.getConnection(url, props); + connect.setAutoCommit(false); + } + } catch(Exception e) { + logger.error(lang.getValue("errors", "connectionError").toString(), e); + throw new ExceptionDBGit(e); + } + + } + + public void flushConnection() { + dbGitConnection = null; + } + + public static DBConnection getInstance() throws ExceptionDBGit { + return getInstance(true); + } + + public static DBConnection getInstance(Boolean isConnect) throws ExceptionDBGit { + if (dbGitConnection == null) { + dbGitConnection = new DBConnection(isConnect); + } + return dbGitConnection; + } + + public Connection getConnect() throws ExceptionDBGit { + return connect; + } + + public boolean testingConnection() { + try { + Properties props = new Properties(); + String url = loadFileDBLink(props); + + Connection conTest = DriverManager.getConnection(url, props); + ConsoleWriter.printlnGreen(lang.getValue("general", "link", "connectionEstablished")); + conTest.close(); + conTest = null; + return true; + } catch(Exception e) { + ConsoleWriter.printlnRed(lang.getValue("errors", "link", "cantConnect") + ": " + e.getMessage()); + return false; + } + } + + public boolean testingConnection(String url, Properties props) { + try { + Connection conTest = DriverManager.getConnection(url, props); + ConsoleWriter.printlnGreen(lang.getValue("general", "link", "connectionEstablished")); + conTest.close(); + conTest = null; + return true; + } catch(Exception e) { + ConsoleWriter.printlnRed(lang.getValue("errors", "link", "cantConnect") + ": " + e.getMessage()); + return false; + } + } + + public static void createFileDBLink(String url, Properties props, boolean isDefault) throws ExceptionDBGit { + try{ + File file; + + if (isDefault) + file = new File(DBGitPath.getFullPath(DBGitPath.DB_LINK_DEF_FILE)); + else + file = new File(DBGitPath.getFullPath(DBGitPath.DB_LINK_FILE)); + + DBGitPath.createDir(file.getParent()); + + DBGitPath.createDefaultDbgitConfig(DBGitPath.getFullPath()); + DBGitPath.createLogDir(); + DBGitPath.createScriptsDir(); + + FileWriter writer = new FileWriter(file.getAbsolutePath()); + writer.write("url="+url+"\n"); + Enumeration e = props.propertyNames(); + + while (e.hasMoreElements()) { + String key = (String) e.nextElement(); + writer.write(key+"="+ props.getProperty(key)+"\n"); + } + writer.close(); + ConsoleWriter.detailsPrintLn( + DBGitLang.getInstance().getValue("general", "link", "dblinkCreated") + .withParams(DBGitPath.getFullPath(DBGitPath.DB_LINK_FILE)) + , 1 + ); + } catch(Exception e) { + throw new ExceptionDBGit(e); + } + } + + public static String loadFileDBLink(Properties props) throws ExceptionDBGit { + try{ + File file = new File(DBGitPath.getFullPath(DBGitPath.DB_LINK_FILE)); + File fileDef = new File(DBGitPath.getFullPath(DBGitPath.DB_LINK_DEF_FILE)); + + if (!file.exists() && !fileDef.exists()) { + return null; + } + + FileInputStream fis = new FileInputStream(file.exists() ? file : fileDef); + props.load(fis); + fis.close(); + + String url = props.getProperty("url"); + props.remove("url"); + + return url; + } catch(Exception e) { + throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "fileLoadError").withParams(DBGitPath.DB_LINK_FILE), e); + } + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index d1c7eb1..6c058c4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -1,10 +1,12 @@ package ru.fusionsoft.dbgit.core; import java.io.File; +import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; import java.util.Set; +import com.diogonunes.jcdp.color.api.Ansi; import org.eclipse.jgit.api.*; import org.eclipse.jgit.api.ListBranchCommand.ListMode; import org.eclipse.jgit.api.ResetCommand.ResetType; @@ -13,6 +15,7 @@ import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.revwalk.RevCommit; +import org.eclipse.jgit.revwalk.RevWalk; import org.eclipse.jgit.storage.file.FileRepositoryBuilder; import org.eclipse.jgit.transport.CredentialsProvider; import org.eclipse.jgit.transport.PushResult; @@ -248,10 +251,13 @@ public void gitCommit(boolean existsSwitchA, String msg, String path) throws Exc public void gitCheckout(String branch, String commit, boolean isNewBranch) throws ExceptionDBGit { try { - ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("general", "checkout", "toCreateBranch") + ": " + isNewBranch); - ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("general", "checkout", "branchName") + ": " + branch); + ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("general", "checkout", "do")); + ConsoleWriter.detailsPrintLnColor(DBGitLang.getInstance().getValue("general", "checkout", "toCreateBranch") + ": " + isNewBranch, 1, Ansi.FColor.GREEN); + ConsoleWriter.detailsPrintLnColor(DBGitLang.getInstance().getValue("general", "checkout", "branchName") + ": " + branch, 1, Ansi.FColor.GREEN); if (commit != null) - ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("general", "checkout", "commitName") + ": " + commit); + ConsoleWriter.detailsPrintLnColor(DBGitLang.getInstance().getValue("general", "checkout", "commitName") + ": " + commit, 1, Ansi.FColor.GREEN); + + Ref result; if (git.getRepository().findRef(branch) != null || isNewBranch) { @@ -269,7 +275,14 @@ public void gitCheckout(String branch, String commit, boolean isNewBranch) throw result = checkout.call(); -// ConsoleWriter.printlnGreen(result != null ? result.getName() : commit); + try(RevWalk walk = new RevWalk(repository)){ + ConsoleWriter.detailsPrintLnColor(MessageFormat.format("{0}: {1}" + , DBGitLang.getInstance().getValue("general", "checkout", "commitMessage") + , walk.parseCommit(repository.getAllRefs().get("HEAD").getObjectId()).getShortMessage() + ), 1, Ansi.FColor.GREEN); + } + + } else { MaskFilter maskAdd = new MaskFilter(branch); @@ -282,12 +295,12 @@ public void gitCheckout(String branch, String commit, boolean isNewBranch) throw } String s = ""; if (counter != 1) s = "s"; - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "checkout", "updatedFromIndex").withParams(String.valueOf(counter), s)); + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "checkout", "updatedFromIndex").withParams(String.valueOf(counter), s), 1); } } catch (Exception e) { - throw new ExceptionDBGit(e.getLocalizedMessage()); + throw new ExceptionDBGit(e); } } @@ -301,7 +314,7 @@ public void gitMerge(Set branches) throws ExceptionDBGit { MergeResult result = merge.call(); - ConsoleWriter.println(result.getMergeStatus().toString()); + ConsoleWriter.println(result.getMergeStatus().toString(), 1); } catch (Exception e) { throw new ExceptionDBGit(e); @@ -318,7 +331,11 @@ public void gitPull(String remote, String remoteBranch) throws ExceptionDBGit { if (remoteBranch.length() > 0) pull = pull.setRemoteBranchName(remoteBranch); - ConsoleWriter.printlnGreen(pull.setCredentialsProvider(getCredentialsProviderByName(pull.getRemote())).call().toString()); + ConsoleWriter.printlnGreen( + pull.setCredentialsProvider(getCredentialsProviderByName(pull.getRemote())).call() + .toString() + , 1 + ); } catch (Exception e) { ConsoleWriter.println("Repo is empty!"); //throw new ExceptionDBGit(e); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java index 9004cd8..eea468c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java @@ -33,14 +33,18 @@ public ExceptionDBGit(String msg) { } public ExceptionDBGit(String message, Throwable cause) { -// super(message, cause); + rollbackConnection(); - ConsoleWriter.printlnRed(message); - if(!cause.getMessage().equals(message)) { - ConsoleWriter.printlnRed(cause.getLocalizedMessage()); + + if(message != null && !message.equals(cause.getMessage())) { + ConsoleWriter.printlnRed(message); } - ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(cause)); - logger.error(message, cause); + + ConsoleWriter.printlnRed(cause.getLocalizedMessage()); + ConsoleWriter.detailsPrintlnRed(ExceptionUtils.getStackTrace(cause)); + ConsoleWriter.printlnRed(""); + + logger.error(message != null ? message : cause.getMessage(), cause); System.exit(1); } @@ -58,8 +62,7 @@ private void rollbackConnection() { } public ExceptionDBGit(Throwable cause) { - super(cause); - logger.error(cause.getLocalizedMessage(), cause); + this(null, cause); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java index df7e609..9d9f72f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java @@ -286,11 +286,12 @@ public IMapMetaObject loadFileMetaData(boolean force) throws ExceptionDBGit { List files = dbGit.getGitIndexFiles(DBGitPath.DB_GIT_PATH); boolean isSuccessful = true; - + + ConsoleWriter.detailsPrintLn("Loading files...", 1); for (int i = 0; i < files.size(); i++) { String filename = files.get(i); if (DBGitPath.isServiceFile(filename)) continue; - ConsoleWriter.detailsPrint("\nLoading file " + filename + "...", 1); + ConsoleWriter.detailsPrintLn("Loading file " + filename + "...", 2); if (force) { IMetaObject obj = loadMetaFile(filename); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBBackupAdapterMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBBackupAdapterMssql.java index 102a891..7c8b765 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBBackupAdapterMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBBackupAdapterMssql.java @@ -43,7 +43,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio createSchema(stLog, schema); } - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); ddl = ddl.replace(schema + "." + objectName, getFullDbName(schema, objectName)); @@ -53,7 +53,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if (file.exists()) obj = metaSql.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else if (obj instanceof MetaTable) { @@ -77,7 +77,7 @@ else if (obj instanceof MetaTable) { createSchema(stLog, schema); } - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); dropIfExists(isSaveToSchema() ? PREFIX + schema : schema, isSaveToSchema() ? objectName : PREFIX + objectName, stLog); @@ -123,7 +123,7 @@ else if (obj instanceof MetaTable) { File file = new File(DBGitPath.getFullPath() + metaTable.getFileName()); if (file.exists()) obj = metaTable.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else if (obj instanceof MetaSequence) { MetaSequence metaSequence = (MetaSequence) obj; @@ -138,7 +138,7 @@ else if (obj instanceof MetaSequence) { String sequenceName = getFullDbName(schema, objectName); - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); StringProperties props = metaSequence.getSequence().getOptions(); String seqName = props.get("name").getData(); @@ -178,7 +178,7 @@ else if (obj instanceof MetaSequence) { File file = new File(DBGitPath.getFullPath() + metaSequence.getFileName()); if (file.exists()) obj = metaSequence.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } catch (SQLException e1) { @@ -285,7 +285,7 @@ public boolean isExists(String owner, String objectName) throws SQLException { public boolean createSchema(StatementLogging stLog, String schema) { try { if (!adapter.getSchemes().containsKey(schema)) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema)); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), 3); stLog.execute(MessageFormat.format("CREATE SCHEMA {0}{1}", PREFIX, schema)); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreFunctionMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreFunctionMssql.java index 79bbd94..5fb010d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreFunctionMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreFunctionMssql.java @@ -21,7 +21,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreFnc").withParams(obj.getName()), 1); try { if (obj instanceof MetaFunction) { MetaFunction restoreFunction = (MetaFunction)obj; @@ -60,7 +59,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreProcedureMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreProcedureMssql.java index 8e9c6f9..b7bafa1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreProcedureMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreProcedureMssql.java @@ -21,7 +21,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restorePrc").withParams(obj.getName()), 1); try { if (obj instanceof MetaProcedure) { MetaProcedure restoreProcedure = (MetaProcedure)obj; @@ -42,7 +41,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { st.execute(restoreProcedure.getSqlObject().getSql(), "/"); //TODO Восстановление привилегий } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreRoleMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreRoleMssql.java index 8abc027..06a46ad 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreRoleMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreRoleMssql.java @@ -21,7 +21,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreRole").withParams(obj.getName()), 1); try { if (obj instanceof MetaRole) { MetaRole restoreRole = (MetaRole)obj; @@ -67,7 +66,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java index 65994b6..fdec25b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java @@ -19,7 +19,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSchema").withParams(obj.getName()), 1); try { if (obj instanceof MetaSchema) { MetaSchema restoreSchema = (MetaSchema)obj; @@ -56,7 +55,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSequenceMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSequenceMssql.java index 6c5fde3..b84b134 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSequenceMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSequenceMssql.java @@ -22,7 +22,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSeq").withParams(obj.getName()), 1); try { if (obj instanceof MetaSequence) { @@ -87,7 +86,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java index a3c5aec..ce7256b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java @@ -121,7 +121,6 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema + "." + restoreTableData.getTable().getName(); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "tableData").withParams(tblName) + "\n", 1); // TODO MSSQL restore TableData script ResultSet rsTypes = st.executeQuery("select column_name, data_type from information_schema.columns \r\n" + @@ -135,7 +134,7 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData if(!diffTableData.entriesOnlyOnLeft().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 3); for(RowData rowData:diffTableData.entriesOnlyOnLeft().values()) { ArrayList fieldsList = new ArrayList(rowData.getData().keySet()); @@ -171,11 +170,11 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData st.execute(insertQuery); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if(!diffTableData.entriesOnlyOnRight().isEmpty()){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 3); String deleteQuery=""; Map primarykeys = new HashMap(); for(RowData rowData:diffTableData.entriesOnlyOnRight().values()) { @@ -213,11 +212,11 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData if(deleteQuery.length()>1) { st.execute(deleteQuery); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if(!diffTableData.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 3); String updateQuery=""; Map primarykeys = new HashMap(); for(ValueDifference diffRowData:diffTableData.entriesDiffering().values()) { @@ -305,7 +304,7 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); if(updateQuery.length()>1) { ConsoleWriter.println(updateQuery); st.execute(updateQuery); @@ -447,7 +446,7 @@ public String keysToString(Set keys) { } public void restoreTableConstraintMssql(MetaTable table) throws Exception { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), 3); IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -464,7 +463,7 @@ public void restoreTableConstraintMssql(MetaTable table) throws Exception { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(schema + "." + table.getTable().getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -477,7 +476,7 @@ public void removeTableConstraintsMssql(MetaTable table) throws Exception { String schema = getPhisicalSchema(table.getTable().getSchema()); schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema + "." +table.getTable().getName(); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), 1); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), 3); try { //TODO MSSQL remove table constraints script ResultSet rs = stCnt.executeQuery("SELECT *\r\n" + @@ -506,7 +505,7 @@ public void removeTableConstraintsMssql(MetaTable table) throws Exception { } } //} - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } catch (Exception e) { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java index d4852e8..17cee06 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java @@ -1,6 +1,6 @@ package ru.fusionsoft.dbgit.mssql; -import ch.qos.logback.classic.db.names.TableName; +import com.diogonunes.jcdp.color.api.Ansi; import com.google.common.collect.Lists; import com.google.common.collect.MapDifference; import com.google.common.collect.MapDifference.ValueDifference; @@ -53,14 +53,10 @@ public void restoreTableMssql(IMetaObject obj) throws Exception { MetaTable restoreTable = (MetaTable) obj; String tblSchema = getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase()); String tblName = restoreTable.getTable().getName(); - String tblSam = tblSchema+"."+tblName; - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTable").withParams(tblSam) + "\n", 1); - - Map tables = adapter.getTables(tblSchema); if(!isTablePresent(tblSchema ,tblName)){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "createTable"), 2); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "createTable"), 3); DBTable table = restoreTable.getTable(); @@ -72,7 +68,7 @@ public void restoreTableMssql(IMetaObject obj) throws Exception { ")"; st.execute(ddl); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } restoreTableFieldsMssql(restoreTable, tblName, tblSchema, st); @@ -103,7 +99,7 @@ public void restoreTableIndexesMssql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 3); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -182,7 +178,7 @@ public void restoreTableIndexesMssql(IMetaObject obj) throws Exception { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); +// ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -191,7 +187,7 @@ private void restoreTableConstraintMssql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 3); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -222,7 +218,7 @@ private void restoreTableConstraintMssql(IMetaObject obj) throws Exception { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -276,7 +272,7 @@ private void restoreTableFieldsMssql(MetaTable restoreTable, String tblName, Str if( !restoringUniqueFields.isEmpty()){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addColumns"), 2); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "addColumns"), 3); List values = restoringUniqueFields.values() .stream() @@ -288,22 +284,22 @@ private void restoreTableFieldsMssql(MetaTable restoreTable, String tblName, Str st.execute(fieldDdl); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if( !existingUniqueFields.isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 3); for(DBTableField tblField:existingUniqueFields.values()) { String fieldDdl = MessageFormat.format("ALTER TABLE {1} DROP COLUMN [{2}]", tblSam, tblField.getName()); st.execute(fieldDdl); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if(!mergingFields.isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "modifyColumns"), 2); + ConsoleWriter.detailsPrintLnColor(lang.getValue("general", "restore", "modifyColumns"), 3, Ansi.FColor.WHITE); for(ValueDifference fld : mergingFields.values()) { DBTableField oldValue = fld.rightValue(); @@ -323,7 +319,7 @@ private void restoreTableFieldsMssql(MetaTable restoreTable, String tblName, Str } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } @@ -364,7 +360,7 @@ private boolean getIsPk(DBConstraint dbConstraint){ } private void restoreTablePksMssql(MetaTable restoreTable, StatementLogging st) throws SQLException { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 3); String tblSchema = restoreTable.getTable().getSchema(); String tblName = restoreTable.getTable().getName(); boolean flagPkCreated = false; @@ -387,13 +383,13 @@ private void restoreTablePksMssql(MetaTable restoreTable, StatementLogging st) t } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); flagPkCreated = true; if (!flagPkCreated) { for(DBTableField field: restoreTable.getFields().values()) { if (field.getIsPrimaryKey()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 3); String ddl = MessageFormat.format( "ALTER TABLE {0} ADD CONSTRAINT PK_{1}_{2} PRIMARY KEY([{2}])", @@ -401,7 +397,7 @@ private void restoreTablePksMssql(MetaTable restoreTable, StatementLogging st) t ); st.execute(ddl); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); break; + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); break; } } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java index 09349c5..c88c769 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java @@ -19,7 +19,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTableSpace").withParams(obj.getName()), 1); try { if (obj instanceof MetaTableSpace) { MetaTableSpace restoreTableSpace = (MetaTableSpace)obj; @@ -75,7 +74,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTriggerMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTriggerMssql.java index cc2c589..acde79e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTriggerMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTriggerMssql.java @@ -24,7 +24,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTrigger").withParams(obj.getName()), 1); try { if (obj instanceof MetaTrigger) { MetaTrigger restoreTrigger = (MetaTrigger)obj; @@ -71,7 +70,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreUserMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreUserMssql.java index ff16155..78327f6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreUserMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreUserMssql.java @@ -20,7 +20,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreUser").withParams(obj.getName()), 1); try { if (obj instanceof MetaUser) { MetaUser usr = (MetaUser)obj; @@ -67,7 +66,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java index 4b7d8e6..be6332f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java @@ -19,7 +19,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreView").withParams(obj.getName()), 1); try { if (obj instanceof MetaView) { MetaView restoreView = (MetaView)obj; @@ -61,7 +60,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java index 625e397..48430d5 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java @@ -36,7 +36,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { if (isSaveToSchema()) { createSchema(stLog, schema); } - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); ////dropIfExists(isSaveToSchema() ? PREFIX + schema : schema, //// isSaveToSchema() ? objectName : PREFIX + objectName, stLog); //ddl = ddl.replace(schema + "." + objectName, getFullDbName(schema, objectName)); @@ -45,7 +45,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { File file = new File(DBGitPath.getFullPath() + metaSql.getFileName()); if (file.exists()) obj = metaSql.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else if (obj instanceof MetaTable) { MetaTable metaTable = (MetaTable) obj; metaTable.loadFromDB(); @@ -64,7 +64,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { if (isSaveToSchema()) { createSchema(stLog, schema); } - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), 3); //dropIfExists( //isSaveToSchema() ? PREFIX + schema : schema, //isSaveToSchema() ? tableName : PREFIX + tableName, stLog @@ -108,7 +108,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { File file = new File(DBGitPath.getFullPath() + metaTable.getFileName()); if (file.exists()) obj = metaTable.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else if (obj instanceof MetaSequence) { MetaSequence metaSequence = (MetaSequence) obj; metaSequence.loadFromDB(); @@ -118,7 +118,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { createSchema(stLog, schema); } String sequenceName = getFullDbName(schema, objectName); - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); //String ddl = "create sequence " + sequenceName + "\n" //+ (metaSequence.getSequence().getOptions().get("cycle_option").toString().equals("YES") ? "CYCLE\n" : "") //+ " INCREMENT " + metaSequence.getSequence().getOptions().get("increment").toString() + "\n" @@ -134,7 +134,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { File file = new File(DBGitPath.getFullPath() + metaSequence.getFileName()); if (file.exists()) obj = metaSequence.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } catch (SQLException e1) { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError"). @@ -223,7 +223,7 @@ public boolean createSchema(StatementLogging stLog, String schema) { rs.next(); if (rs.getInt("cnt") == 0) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema)); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), 3); stLog.execute("create schema " + PREFIX + schema); } diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java index a300130..7431453 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java @@ -17,7 +17,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSchema").withParams(obj.getName()), 1); try { if (obj instanceof MetaSchema) { MetaSchema restoreSchema = (MetaSchema) obj; @@ -30,7 +29,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return false; diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java index 4bcc280..2eaec06 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java @@ -100,9 +100,8 @@ public void restoreTableDataMySql(MetaTableData restoreTableData, MetaTableData String schema = getPhisicalSchema(restoreTableData.getTable().getSchema()); schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema + ".`" + restoreTableData.getTable().getName() + "`"; - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "tableData").withParams(tblName) + "\n", 1); if (!diffTableData.entriesOnlyOnLeft().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 3); for (RowData rowData : diffTableData.entriesOnlyOnLeft().values()) { String fields = String.join("`, `", rowData.getData().keySet()); String values = String.join(", ", rowData.getData().values().stream().map(row -> valueToString(row)).collect(Collectors.toList())); @@ -110,10 +109,10 @@ public void restoreTableDataMySql(MetaTableData restoreTableData, MetaTableData ConsoleWriter.detailsPrintLn(insertQuery); st.execute(insertQuery); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if (!diffTableData.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 3); String ddl = ""; for (RowData rowData : diffTableData.entriesOnlyOnRight().values()) { Map primarykeys = new HashMap(); @@ -136,10 +135,10 @@ public void restoreTableDataMySql(MetaTableData restoreTableData, MetaTableData if (!ddl.isEmpty()) st.execute("delete from " + tblName + " where " + ddl); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if (!diffTableData.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 3); String updateQuery = ""; //Map primarykeys = new HashMap(); for (ValueDifference diffRowData : diffTableData.entriesDiffering().values()) { @@ -212,7 +211,7 @@ public void restoreTableDataMySql(MetaTableData restoreTableData, MetaTableData } } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); if (!updateQuery.isEmpty()) { ConsoleWriter.println(updateQuery); //st.execute(updateQuery); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java index 29c79ff..e68517a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java @@ -71,8 +71,7 @@ public void restoreTableMySql(IMetaObject obj) throws Exception { String schema = getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase()); schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema + ".`" + restoreTable.getTable().getName() + "`"; - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTable").withParams(tblName) + "\n", 1); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "createTable"), 2); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "createTable"), 3); StringBuilder pk = new StringBuilder(); String ddl = "CREATE TABLE IF NOT EXISTS " + tblName + " (" + restoreTable @@ -84,19 +83,19 @@ public void restoreTableMySql(IMetaObject obj) throws Exception { if (f.getIsPrimaryKey()) pk.append(f.getName() + "`, `"); return "`" + f.getName() + "` " - + f.getTypeSQL() + (f.getFixed() ? "(" + f.getLength() + ")" : "") - + (f.getIsNullable() ? "" : " NOT NULL") - + (f.getDefaultValue() == null ? "" : - (f.getDefaultValue().toLowerCase().contains("nextval(") ? " AUTO_INCREMENT" : "")) - //+ (f.getDefaultValue() == null ? "" : " default " + f.getDefaultValue()) - + (f.getDescription() == null ? "" : " comment '" + f.getDescription() + "'"); + + f.getTypeSQL() + (f.getFixed() ? "(" + f.getLength() + ")" : "") + + (f.getIsNullable() ? "" : " NOT NULL") + + (f.getDefaultValue() == null ? "" : + (f.getDefaultValue().toLowerCase().contains("nextval(") ? " AUTO_INCREMENT" : "")) + //+ (f.getDefaultValue() == null ? "" : " default " + f.getDefaultValue()) + + (f.getDescription() == null ? "" : " comment '" + f.getDescription() + "'"); } ).collect(Collectors.joining(", ")) + (pk.length() > 1 ? ", PRIMARY KEY (`" + pk.replace(pk.length() - 4, pk.length(), "").toString() + "`)" : "") //FIXME: add foreign keys + ");"; st.execute(ddl); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); } @@ -112,7 +111,7 @@ public void restoreTableIndexesMySql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 3); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -184,7 +183,7 @@ public void restoreTableIndexesMySql(IMetaObject obj) throws Exception { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); +// ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -193,7 +192,7 @@ private void restoreTableConstraintMySql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 3); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -233,7 +232,7 @@ private void restoreTableConstraintMySql(IMetaObject obj) throws Exception { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreUserMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreUserMySql.java index ddebfa7..fb603b8 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreUserMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreUserMySql.java @@ -16,7 +16,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreUser").withParams(obj.getName()), 1); try { if (obj instanceof MetaUser) { MetaUser usr = (MetaUser)obj; @@ -31,7 +30,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java index 56cedbd..9cd4999 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java @@ -17,7 +17,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreView").withParams(obj.getName()), 1); try { if (obj instanceof MetaView) { MetaView restoreView = (MetaView)obj; @@ -32,7 +31,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBBackupAdapterOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBBackupAdapterOracle.java index 9f60a8c..f0c3946 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBBackupAdapterOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBBackupAdapterOracle.java @@ -30,7 +30,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio String ddl = metaSql.getSqlObject().getSql(); String schema = metaSql.getSqlObject().getSchema(); - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); ddl = replaceNames(ddl, schema, objectName, stLog); @@ -54,7 +54,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if (file.exists()) obj = metaSql.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else if (obj instanceof MetaTable) { MetaTable metaTable = (MetaTable) obj; metaTable.loadFromDB(); @@ -64,7 +64,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if(!isExists(schema, objectName)) return obj; - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); if (isToSaveData()) { @@ -98,7 +98,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if (file.exists()) obj = metaTable.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else if (obj instanceof MetaSequence) { MetaSequence metaSequence = (MetaSequence) obj; metaSequence.loadFromDB(); @@ -108,7 +108,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio String ddl = metaSequence.getSequence().getOptions().get("ddl").toString(); - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); ddl = replaceNames(ddl, schema, objectName, stLog); @@ -118,7 +118,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if (file.exists()) obj = metaSequence.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } catch (Exception e) { @@ -205,7 +205,7 @@ public boolean createSchema(StatementLogging stLog, String schema){ ResultSet rs = st.executeQuery("select count(*) cnt from all_users where USERNAME = '" + PREFIX + schema + "'"); rs.next(); if (rs.getInt("cnt") == 0) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema)); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), 3); stLog.execute("create USER \"" + PREFIX + schema + "\"\r\n" + "IDENTIFIED BY \"" + PREFIX + schema + "\"\r\n" + "DEFAULT TABLESPACE \"SYSTEM\"\r\n" + diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreFunctionOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreFunctionOracle.java index 24023e7..1050662 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreFunctionOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreFunctionOracle.java @@ -19,7 +19,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreFnc").withParams(obj.getName()), 1); try { if (obj instanceof MetaFunction) { MetaFunction restoreFunction = (MetaFunction)obj; @@ -51,7 +50,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java index 2d5aea9..14a067c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java @@ -23,7 +23,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restorePkg").withParams(obj.getName()), 1); try { if (obj instanceof MetaPackage) { MetaPackage restorePackage = (MetaPackage) obj; @@ -45,7 +44,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { executeSql(restorePackage.getSqlObject().getSql()); //TODO Восстановление привилегий } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreProcedureOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreProcedureOracle.java index 68562b7..75dc7aa 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreProcedureOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreProcedureOracle.java @@ -20,8 +20,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restorePrc").withParams(obj.getName()), 1); - try { + try { if (obj instanceof MetaProcedure) { MetaProcedure restoreProcedure = (MetaProcedure)obj; Map prcds = adapter.getProcedures(restoreProcedure.getSqlObject().getSchema()); @@ -41,7 +40,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { st.execute(restoreProcedure.getSqlObject().getSql(), "/"); //TODO Восстановление привилегий } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreRoleOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreRoleOracle.java index 34d7b1d..0e3f317 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreRoleOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreRoleOracle.java @@ -19,7 +19,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreRole").withParams(obj.getName()), 1); try { if (obj instanceof MetaRole) { MetaRole restoreRole = (MetaRole)obj; @@ -60,7 +59,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } //TODO restore memberOfRole - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSchemaOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSchemaOracle.java index 124f148..f24f969 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSchemaOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSchemaOracle.java @@ -18,7 +18,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSchema").withParams(obj.getName()), 1); try { if (obj instanceof MetaSchema) { MetaSchema restoreSchema = (MetaSchema)obj; @@ -44,7 +43,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { setPassword(restoreSchema)); //TODO Восстановление привилегий } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSequenceOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSequenceOracle.java index 44846c9..b8cccd2 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSequenceOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSequenceOracle.java @@ -19,7 +19,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSeq").withParams(obj.getName()), 1); try { if (obj instanceof MetaSequence) { MetaSequence restoreSeq = (MetaSequence)obj; @@ -82,7 +81,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { st.execute(query); //TODO Восстановление привилегий } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java index 9736ced..27c6e88 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java @@ -123,7 +123,6 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat try { String tblName = getPhisicalSchema(restoreTableData.getTable().getSchema()) + "." + restoreTableData.getTable().getName(); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "tableData").withParams(tblName) + "\n", 1); String insertQuery= ""; @@ -146,7 +145,7 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat } if(!diffTableData.entriesOnlyOnLeft().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 3); for(RowData rowData:diffTableData.entriesOnlyOnLeft().values()) { ArrayList fieldsList = new ArrayList(rowData.getData().keySet()); @@ -173,12 +172,12 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat st.execute(insertQuery); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if(!diffTableData.entriesOnlyOnRight().isEmpty()) { boolean isSuccessful = true; - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 3); for(RowData rowData : diffTableData.entriesOnlyOnRight().values()) { Map primarykeys = getKeys(rowData); @@ -204,14 +203,14 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat if(!diffTableData.entriesDiffering().isEmpty()) { boolean isSuccessful = true; - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 3); for (ValueDifference diffRowData:diffTableData.entriesDiffering().values()) { if (!diffRowData.leftValue().getHashRow().equals(diffRowData.rightValue().getHashRow())) { Map primarykeys = getKeys(diffRowData.leftValue()); if (primarykeys.size() == 0) { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.printlnRed(lang.getValue("general", "restore", "pkNotFound").withParams(tblName)); + ConsoleWriter.printlnRed(lang.getValue("general", "restore", "pkNotFound").withParams(tblName),3); isSuccessful = false; break; } @@ -271,7 +270,7 @@ private Map getKeys(RowData rowData) { primarykeys.put(entry.getKey(), entry.getValue().convertToString()); } } catch (Exception e) { - ConsoleWriter.printlnRed(lang.getValue("general", "restore", "pkNotFound").withParams("")); + ConsoleWriter.printlnRed(lang.getValue("general", "restore", "pkNotFound").withParams(""),3); ConsoleWriter.printlnRed(e.getMessage()); } } @@ -282,7 +281,7 @@ private Map getKeys(RowData rowData) { private void restoreTableConstraintOracle(MetaTable table) throws Exception { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), 1); IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -297,7 +296,7 @@ private void restoreTableConstraintOracle(MetaTable table) throws Exception { st.execute(query); } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } catch (Exception e) { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); @@ -331,7 +330,7 @@ private void removeTableConstraintsOracle(MetaTable table) throws Exception { st.execute(dropQuery, "/"); } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } catch (Exception e) { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java index 0cecf82..ea432b1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java @@ -60,7 +60,6 @@ public void restoreTableOracle(IMetaObject obj) throws Exception String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema+"."+restoreTable.getTable().getName(); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTable").withParams(tblName) + "\n", 1); Map tables = adapter.getTables(schema.toUpperCase()); boolean exist = false; @@ -73,7 +72,7 @@ public void restoreTableOracle(IMetaObject obj) throws Exception } } if(!exist){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "createTable"), 2); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "createTable"), 3); String ddl = ""; if (restoreTable.getTable().getOptions().get("ddl") != null) ddl = restoreTable.getTable().getOptions().get("ddl").getData() @@ -91,14 +90,14 @@ public void restoreTableOracle(IMetaObject obj) throws Exception } st.execute(ddl); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { //restore tabl fields Map currentFileds = adapter.getTableFields(schema, restoreTable.getTable().getName().toLowerCase()); MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),currentFileds); if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addColumns"), 2); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "addColumns"), 3); Comparator comparator = (o1, o2) -> o1.getOrder().compareTo(o2.getOrder()); @@ -108,19 +107,19 @@ public void restoreTableOracle(IMetaObject obj) throws Exception for(DBTableField tblField : values) { st.execute("alter table "+ tblName +" add " + tblField.getName() + " " + tblField.getTypeSQL()); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 3); for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { st.execute("alter table "+ tblName +" drop column "+ tblField.getName()); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if(!diffTableFields.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "modifyColumns"), 2); + ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "modifyColumns"), 3); for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { if(!tblField.leftValue().getName().equals(tblField.rightValue().getName())) { @@ -131,7 +130,7 @@ public void restoreTableOracle(IMetaObject obj) throws Exception st.execute("alter table "+ tblName +" modify "+ tblField.leftValue().getName() +" "+ tblField.leftValue().getTypeSQL()); } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } @@ -153,7 +152,7 @@ public void restoreTableOracle(IMetaObject obj) throws Exception st.execute(tableconst.getOptions().get("ddl").toString().replace(" " +tableconst.getSchema() + ".", " " + schema + ".")); else if (tableconst.getOptions().get("ddl").toString().toLowerCase().startsWith("primary key")) st.execute("alter table "+ tblName +" add constraint PK_"+ tableconst.getName() + tableconst.getOptions().get("ddl").toString()); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); flagPkCreated = true; break; } @@ -164,7 +163,7 @@ else if (tableconst.getOptions().get("ddl").toString().toLowerCase().startsWith( if (field.getIsPrimaryKey()) { ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 2); st.execute("alter table "+ tblName +" add constraint pk_" + restoreTable.getTable().getName() + "_" + field.getName() + " PRIMARY KEY (" + field.getName() + ")"); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); break; } } @@ -274,7 +273,7 @@ public void restoreTableIndexesOracle(IMetaObject obj) throws Exception Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 3); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -310,7 +309,7 @@ public void restoreTableIndexesOracle(IMetaObject obj) throws Exception st.execute(ind.getSql()); } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { @@ -331,7 +330,7 @@ public void restoreTableConstraintOracle(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 3); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -344,7 +343,7 @@ public void restoreTableConstraintOracle(IMetaObject obj) throws Exception { st.execute(constrs.getOptions().get("ddl").toString().replace(" " + constrs.getSchema() + ".", " " + schema + ".")); } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTriggerOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTriggerOracle.java index 3f9a13f..efa3fb6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTriggerOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTriggerOracle.java @@ -21,8 +21,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTrigger").withParams(obj.getName()), 1); - try { + try { if (obj instanceof MetaTrigger) { MetaTrigger restoreTrigger = (MetaTrigger)obj; Map trgs = adapter.getTriggers(restoreTrigger.getSqlObject().getSchema()); @@ -42,7 +41,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { executeSql(restoreTrigger.getSqlObject().getSql()); //TODO Восстановление привилегий } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreViewOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreViewOracle.java index 96de107..61e80b9 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreViewOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreViewOracle.java @@ -21,7 +21,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreView").withParams(obj.getName()), 1); try { if (obj instanceof MetaView) { MetaView restoreView = (MetaView)obj; @@ -44,7 +43,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { st.execute(restoreView.getSqlObject().getSql()); //TODO Восстановление привилегий } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java index 18e26a0..1f0048c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java @@ -39,7 +39,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio createSchema(stLog, schema); } - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); //dropIfExists(isSaveToSchema() ? PREFIX + schema : schema, // isSaveToSchema() ? objectName : PREFIX + objectName, stLog); @@ -54,7 +54,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if (file.exists()) obj = metaSql.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else if (obj instanceof MetaTable) { @@ -77,7 +77,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if (isSaveToSchema()) { createSchema(stLog, schema); } - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), 3); StringBuilder tableDdlSb = new StringBuilder(MessageFormat.format( "create table {0} as (select * from {1}.{2} where 1={3}) {4};\n alter table {0} owner to {5};\n" @@ -151,7 +151,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio File file = new File(DBGitPath.getFullPath() + metaTable.getFileName()); if (file.exists()) obj = metaTable.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else if (obj instanceof MetaSequence) { MetaSequence metaSequence = (MetaSequence) obj; metaSequence.loadFromDB(); @@ -165,7 +165,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio String sequenceName = getFullDbName(schema, objectName); - ConsoleWriter.detailsPrint(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); String ddl = "create sequence " + sequenceName + "\n" + (metaSequence.getSequence().getOptions().get("cycle_option").toString().equals("YES") ? "CYCLE\n" : "") @@ -186,7 +186,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio File file = new File(DBGitPath.getFullPath() + metaSequence.getFileName()); if (file.exists()) obj = metaSequence.loadFromFile(); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } catch (SQLException e1) { @@ -299,7 +299,7 @@ public boolean createSchema(StatementLogging stLog, String schema) { rs.next(); if (rs.getInt("cnt") == 0) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema)); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), 3); stLog.execute("create schema " + adapter.escapeNameIfNeeded(PREFIX + schema)); } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java index 2d01817..3ba29aa 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java @@ -24,7 +24,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); try { if (obj instanceof MetaFunction) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreFnc").withParams(obj.getName()), 1); MetaFunction restoreFunction = (MetaFunction)obj; String restoreFunctionName = restoreFunction.getSqlObject().getName(); @@ -48,11 +47,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { StringProperties restoreProcArgs = restoreFunction.getSqlObject().getOptions().get("arguments"); String args = restoreProcArgs != null ? restoreProcArgs.getData().replaceAll("(\\w+ \\w+) (DEFAULT [^\\,\\n]+)(\\,|\\b)", "$1") : ""; - st.execute(MessageFormat.format("ALTER FUNCTION {0}.{1}({2}) OWNER TO {3}" + st.execute(MessageFormat.format("ALTER FUNCTION {0}.{1}({2}) OWNER TO \"{3}\"" , restoreFunction.getUnderlyingDbObject().getSchema() , adapter.escapeNameIfNeeded(restoreFunctionName) , args - , restoreFunction.getSqlObject().getOwner())); + , restoreFunction.getSqlObject().getOwner()) + ); } //TODO Восстановление привилегий } @@ -73,7 +73,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(e.getLocalizedMessage()); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java index ee1f510..982472c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java @@ -1,107 +1,106 @@ -package ru.fusionsoft.dbgit.postgres; - -import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.dbobjects.DBProcedure; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaProcedure; -import ru.fusionsoft.dbgit.meta.NameMeta; -import ru.fusionsoft.dbgit.statement.StatementLogging; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import ru.fusionsoft.dbgit.utils.StringProperties; - -import java.sql.Connection; -import java.text.MessageFormat; -import java.util.Map; - -public class DBRestoreProcedurePostgres extends DBRestoreAdapter { - - @Override - public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { - if (obj instanceof MetaProcedure) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restorePrc").withParams(obj.getName()), 1); - MetaProcedure restoreProc = (MetaProcedure)obj; - NameMeta nm = new NameMeta(restoreProc); - String restoreProcName = nm.getName(); - Map procs = adapter.getProcedures(nm.getSchema()); - boolean exist = false; - if(!(procs.isEmpty() || procs == null)) { - for(DBProcedure prc : procs.values()) { - if(restoreProcName.equals(prc.getName())){ - exist = true; - - //if codes differ - if( !restoreProc.getSqlObject().getSql() - .replaceAll("\\s+", "") - .equals(prc.getSql().replaceAll("\\s+", "")) - ) { - st.execute(restoreProc.getSqlObject().getSql()); - } - - //if owners differ - if(!restoreProc.getSqlObject().getOwner().equals(prc.getOwner())) { - StringProperties restoreProcArgs = restoreProc.getSqlObject().getOptions().get("arguments"); - String args = restoreProcArgs != null ? restoreProcArgs.getData().replaceAll("(\\w+ \\w+) (DEFAULT [^\\,\\n]+)(\\,|\\b)", "$1") : ""; - - st.execute(MessageFormat.format("ALTER PROCEDURE {0}.{1}({2}) OWNER TO {3}" - , nm.getSchema() - , adapter.escapeNameIfNeeded(restoreProcName) - , args - , restoreProc.getSqlObject().getOwner())); - } - //TODO Восстановление привилегий - } - } - } - if(!exist){ - st.execute(restoreProc.getSqlObject().getSql()); - //TODO Восстановление привилегий - } - } - else - { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.detailsPrintlnRed(e.getLocalizedMessage()); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - st.close(); - } - return true; - } - - @Override - public void removeMetaObject(IMetaObject obj) throws Exception - { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - - try { - if(! (obj instanceof MetaProcedure)) throw new ExceptionDBGit("Wrong IMetaObject type, expected: prc, was: " + obj.getType().getValue()); - MetaProcedure prcMeta = (MetaProcedure) obj; - DBProcedure prc = (DBProcedure) prcMeta.getSqlObject(); - if (prc == null) return; - - String schema = getPhisicalSchema(prc.getSchema()); - st.execute("DROP PROCEDURE "+schema+"."+adapter.escapeNameIfNeeded(prc.getName())); - } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); - } finally { - st.close(); - } - - } - -} +package ru.fusionsoft.dbgit.postgres; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBProcedure; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaProcedure; +import ru.fusionsoft.dbgit.meta.NameMeta; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.utils.StringProperties; + +import java.sql.Connection; +import java.text.MessageFormat; +import java.util.Map; + +public class DBRestoreProcedurePostgres extends DBRestoreAdapter { + + @Override + public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + try { + if (obj instanceof MetaProcedure) { + MetaProcedure restoreProc = (MetaProcedure)obj; + NameMeta nm = new NameMeta(restoreProc); + String restoreProcName = nm.getName(); + Map procs = adapter.getProcedures(nm.getSchema()); + boolean exist = false; + if(!(procs.isEmpty() || procs == null)) { + for(DBProcedure prc : procs.values()) { + if(restoreProcName.equals(prc.getName())){ + exist = true; + + //if codes differ + if( !restoreProc.getSqlObject().getSql() + .replaceAll("\\s+", "") + .equals(prc.getSql().replaceAll("\\s+", "")) + ) { + st.execute(restoreProc.getSqlObject().getSql()); + } + + //if owners differ + if(!restoreProc.getSqlObject().getOwner().equals(prc.getOwner())) { + StringProperties restoreProcArgs = restoreProc.getSqlObject().getOptions().get("arguments"); + String args = restoreProcArgs != null ? restoreProcArgs.getData().replaceAll("(\\w+ \\w+) (DEFAULT [^\\,\\n]+)(\\,|\\b)", "$1") : ""; + + st.execute(MessageFormat.format("ALTER PROCEDURE {0}.{1}({2}) OWNER TO {3}" + , nm.getSchema() + , adapter.escapeNameIfNeeded(restoreProcName) + , args + , restoreProc.getSqlObject().getOwner())); + } + //TODO Восстановление привилегий + } + } + } + if(!exist){ + st.execute(restoreProc.getSqlObject().getSql()); + //TODO Восстановление привилегий + } + } + else + { + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + } + } catch (Exception e) { + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + ConsoleWriter.detailsPrintlnRed(e.getLocalizedMessage()); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + st.close(); + } + return true; + } + + @Override + public void removeMetaObject(IMetaObject obj) throws Exception + { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + + try { + if(! (obj instanceof MetaProcedure)) throw new ExceptionDBGit("Wrong IMetaObject type, expected: prc, was: " + obj.getType().getValue()); + MetaProcedure prcMeta = (MetaProcedure) obj; + DBProcedure prc = (DBProcedure) prcMeta.getSqlObject(); + if (prc == null) return; + + String schema = getPhisicalSchema(prc.getSchema()); + st.execute("DROP PROCEDURE "+schema+"."+adapter.escapeNameIfNeeded(prc.getName())); + } catch (Exception e) { + ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); + } finally { + st.close(); + } + + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreRolePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreRolePostgres.java index 690c950..43f7e59 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreRolePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreRolePostgres.java @@ -19,7 +19,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreRole").withParams(obj.getName()), 1); try { if (obj instanceof MetaRole) { MetaRole restoreRole = (MetaRole)obj; @@ -200,7 +199,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java index 4e214ce..d3db7e1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java @@ -1,66 +1,65 @@ -package ru.fusionsoft.dbgit.postgres; -import java.sql.Connection; -import java.util.Map; - -import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.dbobjects.DBSchema; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaSchema; -import ru.fusionsoft.dbgit.statement.StatementLogging; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - - -public class DBRestoreSchemaPostgres extends DBRestoreAdapter { - @Override - public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSchema").withParams(obj.getName()), 1); - try { - if (obj instanceof MetaSchema) { - MetaSchema restoreSchema = (MetaSchema)obj; - Map schs = adapter.getSchemes(); - boolean exist = false; - if(!(schs.isEmpty() || schs == null)) { - for(DBSchema sch:schs.values()) { - if(restoreSchema.getObjectOption().getName().equals(sch.getName())){ - exist = true; - //String test1 = changedsch.getObjectOption().getName(); - //String test2 = changedsch.getObjectOption().getOptions().getChildren().get("usename").getData(); - if(!restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData().equals(sch.getOptions().getChildren().get("usename").getData())) { - st.execute("ALTER SCHEMA "+ restoreSchema.getObjectOption().getName() +" OWNER TO "+ - restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData()); - } - //TODO Восстановление привилегий - } - } - } - if(!exist){ - st.execute("CREATE SCHEMA "+restoreSchema.getObjectOption().getName() +" AUTHORIZATION "+ - restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData()); - //TODO Восстановление привилегий - } - } - else - { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - st.close(); - } - return true; - } - - public void removeMetaObject(IMetaObject obj) { - // TODO Auto-generated method stub - } - -} +package ru.fusionsoft.dbgit.postgres; +import java.sql.Connection; +import java.util.Map; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBSchema; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaSchema; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + + +public class DBRestoreSchemaPostgres extends DBRestoreAdapter { + @Override + public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + try { + if (obj instanceof MetaSchema) { + MetaSchema restoreSchema = (MetaSchema)obj; + Map schs = adapter.getSchemes(); + boolean exist = false; + if(!(schs.isEmpty() || schs == null)) { + for(DBSchema sch:schs.values()) { + if(restoreSchema.getObjectOption().getName().equals(sch.getName())){ + exist = true; + //String test1 = changedsch.getObjectOption().getName(); + //String test2 = changedsch.getObjectOption().getOptions().getChildren().get("usename").getData(); + if(!restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData().equals(sch.getOptions().getChildren().get("usename").getData())) { + st.execute("ALTER SCHEMA "+ restoreSchema.getObjectOption().getName() +" OWNER TO "+ + restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData()); + } + //TODO Восстановление привилегий + } + } + } + if(!exist){ + st.execute("CREATE SCHEMA "+restoreSchema.getObjectOption().getName() +" AUTHORIZATION "+ + restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData()); + //TODO Восстановление привилегий + } + } + else + { + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + } + } catch (Exception e) { + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + st.close(); + } + return true; + } + + public void removeMetaObject(IMetaObject obj) { + // TODO Auto-generated method stub + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java index 74ccc5d..da3e59e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java @@ -22,7 +22,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreSeq").withParams(obj.getName()), 1); try { if (obj instanceof MetaSequence) { MetaSequence restoreSeq = (MetaSequence)obj; @@ -69,7 +68,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if(query.length()>1) { st.execute(query); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); //TODO Восстановление привилегий } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index 34d856c..b6d878a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -126,16 +126,15 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTableData").withParams(restoreTableData.getName()), 1); List fieldsList = restoreTableData.getFields(); if(fieldsList.size() == 0 ) { ConsoleWriter.detailsPrintlnRed("Empty fieldList, maybe empty csv"); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); return; } if (restoreTableData.getmapRows() == null) { ConsoleWriter.detailsPrintlnRed("MapRows is null, maybe empty csv"); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); return; } @@ -187,7 +186,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa if (deleteQuery.length() > 1) { st.execute(deleteQuery.toString()); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } //UPDATE @@ -238,7 +237,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); if (updateQuery.length() > 1) { ConsoleWriter.println(updateQuery); st.execute(updateQuery); @@ -258,7 +257,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa ConsoleWriter.detailsPrintLn(insertQuery); st.execute(insertQuery); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } catch (Exception e) { @@ -420,7 +419,7 @@ public void restoreTableConstraintPostgres(MetaTable table) throws Exception { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(schema + "." + table.getTable().getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -461,7 +460,7 @@ public void removeTableConstraintsPostgres(MetaTable table) throws Exception { } } //} - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } catch (Exception e) { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 73a5b3c..e5ba8dd 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -32,6 +32,7 @@ public class DBRestoreTablePostgres extends DBRestoreAdapter { @Override public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + if(Integer.valueOf(step).equals(0)) { restoreTablePostgres(obj); return false; @@ -86,24 +87,24 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception { MetaTable restoreTable = (MetaTable)obj; MetaTable existingTable = new MetaTable(restoreTable.getTable()); + String schema = adapter.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase())); String tblName = adapter.escapeNameIfNeeded(restoreTable.getTable().getName()); String tblSam = adapter.escapeNameIfNeeded(schema) + "." + adapter.escapeNameIfNeeded(tblName); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTable").withParams(schema+"."+tblName), 1); //find existing table and set tablespace or create if (existingTable.loadFromDB()){ restoreTableTablespace(st, restoreTable, existingTable); restoreTableOwner(st, restoreTable, existingTable); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "createTable"), 2); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "createTable"), 3); createTable(st, restoreTable); - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } @@ -127,7 +128,7 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 3); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -186,7 +187,7 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); +// ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -196,7 +197,7 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); try { if (obj instanceof MetaTable) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTableConstraints").withParams(obj.getName()), 1); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreTableConstraints").withParams(obj.getName()), 2); MetaTable restoreTable = (MetaTable)obj; MetaTable existingTable = new MetaTable(restoreTable.getTable()); existingTable.loadFromDB(); @@ -225,20 +226,18 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { //process intersects for (ValueDifference constr : diff.entriesDiffering().values()){ - MapDifference propsDiff = Maps.difference(constr.leftValue().getOptions().getChildren(), constr.leftValue().getOptions().getChildren()); - ConsoleWriter.printlnColor("Difference in constraints: " + propsDiff.toString(), Ansi.FColor.MAGENTA, 1); + //MapDifference propsDiff = Maps.difference(constr.leftValue().getOptions().getChildren(), constr.leftValue().getOptions().getChildren()); + //ConsoleWriter.printlnColor("Difference in constraints: " + propsDiff.toString(), Ansi.FColor.MAGENTA, 1); createConstraint(restoreTable, constr.rightValue(), st, true); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); @@ -265,7 +264,7 @@ private void restoreTableFields(MetaTable restoreTable, MetaTable existingTable, MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),existingTable.getFields()); if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addColumns"), 0); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "addColumns"), 3); List fields = diffTableFields.entriesOnlyOnLeft().values().stream() .sorted(Comparator.comparing(DBTableField::getOrder)) @@ -275,20 +274,20 @@ private void restoreTableFields(MetaTable restoreTable, MetaTable existingTable, lastField = tblField.getName(); addColumn(tblSam, tblField, st); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 2); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "droppingColumns"), 3); for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { lastField = tblField.getName(); dropColumn(tblSam, tblField, st); } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if(!diffTableFields.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "modifyColumns"), 2); + ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "modifyColumns"), 3); for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { lastField = tblField.leftValue().getName(); @@ -324,12 +323,12 @@ && hasNotTypeSql(tblField, "text") // ); } } - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } catch (Exception e) { - throw new ExceptionDBGitRestore( + throw new ExceptionDBGit( lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTable.getName()+"#"+lastField) - + "\n" + e.getMessage() + , e ); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java index 90e83b3..081ceaa 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java @@ -1,89 +1,89 @@ -package ru.fusionsoft.dbgit.postgres; - -import java.sql.Connection; -import java.util.Map; - -import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaTableSpace; -import ru.fusionsoft.dbgit.statement.StatementLogging; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -public class DBRestoreTableSpacePostgres extends DBRestoreAdapter{ - - @Override - public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTableSpace").withParams(obj.getName()), 1); - try { - if (obj instanceof MetaTableSpace) { - MetaTableSpace restoreTableSpace = (MetaTableSpace)obj; - Map tblspaces = adapter.getTableSpaces(); - boolean exist = false; - if(!(tblspaces.isEmpty() || tblspaces == null)) { - for(DBTableSpace tblspace:tblspaces.values()) { - if(restoreTableSpace.getObjectOption().getName().equals(tblspace.getName())){ - exist = true; - - String restorename = restoreTableSpace.getObjectOption().getName(); - String restoreowner = restoreTableSpace.getObjectOption().getOptions().getChildren().get("usename").getData(); - String restoreloc = restoreTableSpace.getObjectOption().getOptions().getChildren().get("pg_tablespace_location").getData(); - - st.execute("alter tablespace "+ restorename +" reset (seq_page_cost, random_page_cost, effective_io_concurrency)"); - - String currentname = tblspace.getName(); - String currentowner = tblspace.getOptions().getChildren().get("usename").getData(); - String currentloc = tblspace.getOptions().getChildren().get("pg_tablespace_location").getData(); - - if(!restoreowner.equals(currentowner)) { - st.execute("alter tablespace "+ restorename +" owner to "+ restoreowner); - } - - if(restoreTableSpace.getObjectOption().getOptions().getChildren().containsKey("spcoptions")) { - String options = restoreTableSpace.getObjectOption().getOptions().getChildren().get("spcoptions").getData().replaceAll("[\\{\\}]", ""); - st.execute("alter tablespace "+ restorename +" set ("+ options+")"); - } - - - /*if() { - //TODO Restore location ??? - }*/ - //TODO Восстановление привилегий - } - } - } - if(!exist){ - - //TODO Восстановление привилегий - } - else { - - } - } - else - { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); - st.close(); - } - return true; - } - - @Override - public void removeMetaObject(IMetaObject obj) throws Exception { - // TODO Auto-generated method stub - - } - -} +package ru.fusionsoft.dbgit.postgres; + +import java.sql.Connection; +import java.util.Map; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaTableSpace; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +public class DBRestoreTableSpacePostgres extends DBRestoreAdapter{ + + @Override + public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + try { + if (obj instanceof MetaTableSpace) { + MetaTableSpace restoreTableSpace = (MetaTableSpace)obj; + Map tblspaces = adapter.getTableSpaces(); + boolean exist = false; + if(!(tblspaces.isEmpty() || tblspaces == null)) { + for(DBTableSpace tblspace:tblspaces.values()) { + if(restoreTableSpace.getObjectOption().getName().equals(tblspace.getName())){ + exist = true; + + String restorename = restoreTableSpace.getObjectOption().getName(); + String restoreowner = restoreTableSpace.getObjectOption().getOptions().getChildren().get("usename").getData(); + String restoreloc = restoreTableSpace.getObjectOption().getOptions().getChildren().get("pg_tablespace_location").getData(); + + st.execute("alter tablespace "+ restorename +" reset (seq_page_cost, random_page_cost, effective_io_concurrency)"); + + String currentname = tblspace.getName(); + String currentowner = tblspace.getOptions().getChildren().get("usename").getData(); + String currentloc = tblspace.getOptions().getChildren().get("pg_tablespace_location").getData(); + + if(!restoreowner.equals(currentowner)) { + st.execute("alter tablespace "+ restorename +" owner to "+ restoreowner); + } + + if(restoreTableSpace.getObjectOption().getOptions().getChildren().containsKey("spcoptions")) { + String options = restoreTableSpace.getObjectOption().getOptions().getChildren().get("spcoptions").getData().replaceAll("[\\{\\}]", ""); + st.execute("alter tablespace "+ restorename +" set ("+ options+")"); + } + + + /*if() { + //TODO Restore location ??? + }*/ + //TODO Восстановление привилегий + } + } + } + if(!exist){ + + //TODO Восстановление привилегий + } + else { + + } + } + else + { + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + } + } catch (Exception e) { + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + st.close(); + } + return true; + } + + @Override + public void removeMetaObject(IMetaObject obj) throws Exception { + // TODO Auto-generated method stub + + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java index d09abac..008163f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java @@ -21,7 +21,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreTrigger").withParams(obj.getName()), 1); try { if (obj instanceof MetaTrigger) { MetaTrigger restoreTrigger = (MetaTrigger)obj; @@ -59,7 +58,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUserPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUserPostgres.java index 44b24a5..b36b20e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUserPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUserPostgres.java @@ -17,7 +17,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "restoreUser").withParams(obj.getName()), 1); try { if (obj instanceof MetaUser) { MetaUser usr = (MetaUser)obj; @@ -32,7 +31,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java index 77161ed..49a30c9 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java @@ -56,7 +56,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { - ConsoleWriter.detailsPrintlnGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } return true; diff --git a/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java b/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java index 0db3638..2e03955 100644 --- a/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java +++ b/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java @@ -23,40 +23,63 @@ public static void detailsPrintColor(Object msg, int level, FColor color) { if (showDetailedLog) printColor(msg.toString(), color, level); } + public static void detailsPrintLnColor(Object msg, int level, FColor color) { + if (showDetailedLog) + printlnColor(msg.toString(), color, level); + } public static void detailsPrint(Object msg, int level) { if (showDetailedLog) print(msg.toString(), level); } - public static void detailsPrintlnGreen(Object msg) { - if (showDetailedLog) - printlnColor(msg.toString(), FColor.GREEN, 0); - } - + public static void detailsPrintlnRed(Object msg) { if (showDetailedLog) printlnColor(msg.toString(), FColor.RED, 0); } + public static void printlnGreen(Object msg, int level) { + printlnColor(msg.toString(), FColor.GREEN, level); + } + public static void printlnGreen(Object msg) { printlnColor(msg.toString(), FColor.GREEN, 0); } - + public static void printlnRed(Object msg) { printlnColor(msg.toString(), FColor.RED, 0); } + + public static void printlnRed(Object msg, int level) { + printlnColor(msg.toString(), FColor.RED, level); + } public static void detailsPrintLn(String msg) { if (showDetailedLog) println(msg); } + public static void detailsPrintLn(String msg, int level) { + if (showDetailedLog) + println(msg, level); + } + + public static void detailsPrintLn(Object msg, int level) { + if (showDetailedLog) + println(msg.toString(), level); + } + public static void detailsPrint(String msg, int level) { if (showDetailedLog) print(msg, level); } + public static void detailsPrintGreen(Object msg) { + if (showDetailedLog) + printColor(msg.toString(), FColor.GREEN, 0); + } + public static void detailsPrintlnGreen(String msg) { if (showDetailedLog) printlnColor(msg, FColor.GREEN, 0); @@ -81,7 +104,8 @@ public static void printlnColor(String msg, FColor color, Integer level) { System.out.println(tab + msg); if (1==1) return ; */ - cp.println(tab+msg, Attribute.NONE, color, BColor.BLACK); + + cp.print("\n"+tab+msg, Attribute.NONE, color, BColor.BLACK); cp.clear(); //logger.info(msg); } @@ -111,21 +135,33 @@ public static void println(String msg, Integer level) { System.out.println(tab + msg); if (1==1) return ; */ - cp.println(tab+msg); + printWhite("\n"+tab+msg); cp.clear(); //logger.info(msg); } - + + public static void println(Object msg, Integer level) { + println(msg.toString(), level); + } + public static void print(String msg, Integer level) { String tab = StringUtils.leftPad("", 4*level, " "); /* System.out.println(tab + msg); if (1==1) return ; */ - cp.print(tab+msg); - cp.clear(); + printWhite(tab+msg); //logger.info(msg); } + public static void print(Object msg, Integer level) { + print(msg.toString(), level); + } + public static void print(String msg) { + print(msg, 0); + } + public static void print(Object msg) { + print(msg.toString()); + } public static void setDetailedLog(boolean toShowLog) { showDetailedLog = toShowLog; @@ -134,4 +170,8 @@ public static void setDetailedLog(boolean toShowLog) { public static boolean getDetailedLog() { return showDetailedLog; } + public static void printWhite(String message){ + cp.print(message, Attribute.NONE, FColor.WHITE, BColor.BLACK); + cp.clear(); + } } diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index d5b6eb1..c8da2f0 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -14,9 +14,11 @@ general: connectionEstablished: Connection established dblinkCreated: File {0} has been created checkout: + do: Do checkout... toCreateBranch: To create new branch branchName: Branch name commitName: Commit name + commitMessage: Commit message updatedFromIndex: Updated {0} path{1} from the index clone: cloned: Repository cloned @@ -44,14 +46,19 @@ general: fetch: fetching: Fetching... restore: + do: Do restore... scriptWillSaveTo: Script will be saved to {0} seekingToRemove: Seeking objects to remove... seekingToRestore: Seeking objects to restore... + seekingToRestoreAdditional: Seeking additional dependant objects to restore... toRestore: "Objects to restore:" + toRestoreAdditional: "Additional to restore:" toRemove: "Objects to remove:" notExists: Object {0} not exists in db, it will be removed from index + objectToRemove: Object {0} marked to delete nothingToRemove: No objects to remove nothingToRestore: No objects to restore + nothingToRestoreAdditional: No additional objects to restore restoring: Restoring... removing: Removing... removingObject: Removing {0}... @@ -77,6 +84,9 @@ general: addColumns: Adding columns... modifyColumns: Modifying columns... droppingColumns: Dropping columns... + droppingTablesConstraints: Dropping constraints for all updating tables... + droppingTableConstraints: Dropping constraints for table {0}... + restoringTablesConstraints: Restoring constraints for all updated tables... addPk: Adding PK... inserting: Inserting... deleting: Deleting... @@ -84,7 +94,7 @@ general: unsupportedTypes: Table {0} contains unsupported types, it will be skipped willMakeBackup: Backup option enabled, all objects will be backed up before making changes toMakeChanges: Restore key specified, the operation will make changes to database - notMakeChanges: The operation will NOT make changes to database, a sql script was generated at {0}. Use "-r" key to make changes. + notMakeChanges: The operation will NOT make changes to database rm: checking: Checking files deleting: Deleting @@ -121,6 +131,9 @@ general: tryingToCopy: Trying to copy {0} to {1}... creatingSchema: Creating schema {0} droppingBackup: Dropping backup object {0}... + tryToBackup: Try to backup {0} present of {1} restoring objects ... + dependingBackups: Found {0} depending backups - {1} + rewritingBackups: Rewriting {0} backups with {1} found dependencies errors: commandNotFound: Command {0} not found! executionError: Error execute dbgit @@ -267,13 +280,18 @@ help: dbgit add /TEST_VIEW.vw add-c: Let you continue adding from last place if it was broken checkout: | + Calls git checkout and 'dbgit restore' then Example: - dbgit checkout master + dbgit checkout master # checkout and restore (only script generated) + dbgit checkout master -r # checkout and restore with changing database + dbgit checkout master -nodb # checkout only + dbgit checkout -ls # see current branch checkout-b: create and checkout a new branch checkout-r: Updates database checkout-u: Upgrades branch to actual db and dbgit version state checkout-ls: Just see current branch, head and revision number checkout-no-db: Doesn't do restore after checkout + checkout-no-owner: Doesn't restore objects original owner clone: | Example: dbgit clone diff --git a/src/main/resources/logback.xml b/src/main/resources/logback.xml index 4ba1a99..143b89d 100644 --- a/src/main/resources/logback.xml +++ b/src/main/resources/logback.xml @@ -33,7 +33,7 @@ - %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + %d{HH:mm} %level [%file:%line] : %msg%n @@ -43,7 +43,7 @@ - --> + diff --git a/src/test/resources/logback-test.xml b/src/test/resources/logback-test.xml new file mode 100644 index 0000000..61d5b6b --- /dev/null +++ b/src/test/resources/logback-test.xml @@ -0,0 +1,50 @@ + + + + + + + + + + + .dbgit/logs + + + + + + + + + ${log_dir_rep}/log-${time}.log + + + ${log_dir_home}/log-${time}.log + + + + + %date %level [%thread] %logger{10} [%file:%line] %msg%n + + + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + + + --> + + + + \ No newline at end of file From 0fc3f902e722699c8dbaa6cee3fa44c36e45179e Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 29 Jan 2021 06:48:27 +0300 Subject: [PATCH 38/68] Additional message and exception throw refactor --- src/main/java/ru/fusionsoft/dbgit/App.java | 6 +- .../fusionsoft/dbgit/adapters/DBAdapter.java | 49 +- .../dbgit/adapters/DBBackupAdapter.java | 17 +- .../dbgit/adapters/DBRestoreAdapter.java | 4 +- .../fusionsoft/dbgit/adapters/IDBAdapter.java | 1 + .../dbgit/adapters/IDBBackupAdapter.java | 5 +- .../dbgit/adapters/IDBConvertAdapter.java | 1 + .../IFactoryDBAdapterRestoteMetaData.java | 1 + .../ru/fusionsoft/dbgit/command/CmdAdd.java | 19 +- .../fusionsoft/dbgit/command/CmdCheckout.java | 18 +- .../fusionsoft/dbgit/command/CmdCommit.java | 2 +- .../ru/fusionsoft/dbgit/command/CmdDump.java | 232 ++--- .../ru/fusionsoft/dbgit/command/CmdFetch.java | 2 +- .../ru/fusionsoft/dbgit/command/CmdHelp.java | 2 +- .../ru/fusionsoft/dbgit/command/CmdLink.java | 2 +- .../fusionsoft/dbgit/command/CmdRestore.java | 4 +- .../ru/fusionsoft/dbgit/command/CmdRm.java | 23 +- .../fusionsoft/dbgit/command/CmdStatus.java | 44 +- .../dbgit/command/CmdSynonymSchema.java | 6 +- .../ru/fusionsoft/dbgit/command/CmdValid.java | 4 +- .../dbgit/command/IDBGitCommand.java | 2 + .../fusionsoft/dbgit/command/RequestCmd.java | 13 +- .../fusionsoft/dbgit/core/DBConnection.java | 17 +- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 136 ++- .../ru/fusionsoft/dbgit/core/DBGitConfig.java | 313 +++--- .../ru/fusionsoft/dbgit/core/DBGitLang.java | 1 - .../fusionsoft/dbgit/core/ExceptionDBGit.java | 75 +- .../dbgit/core/ExceptionDBGitRestore.java | 21 +- .../dbgit/core/ExceptionDBGitRunTime.java | 42 +- .../dbgit/core/GitMetaDataManager.java | 35 +- .../dbgit/data_table/MapFileData.java | 7 +- .../ru/fusionsoft/dbgit/meta/IMetaObject.java | 4 +- .../fusionsoft/dbgit/meta/MetaTableData.java | 912 +++++++++--------- .../dbgit/meta/SortedListMetaObject.java | 7 +- .../dbgit/mssql/DBAdapterMssql.java | 8 +- .../dbgit/mssql/DBBackupAdapterMssql.java | 13 +- .../dbgit/mssql/DBRestoreFunctionMssql.java | 7 +- .../dbgit/mssql/DBRestoreProcedureMssql.java | 7 +- .../dbgit/mssql/DBRestoreRoleMssql.java | 8 +- .../dbgit/mssql/DBRestoreSchemaMssql.java | 7 +- .../dbgit/mssql/DBRestoreSequenceMssql.java | 7 +- .../dbgit/mssql/DBRestoreTableDataMssql.java | 42 +- .../dbgit/mssql/DBRestoreTableMssql.java | 46 +- .../dbgit/mssql/DBRestoreTableSpaceMssql.java | 12 +- .../dbgit/mssql/DBRestoreTriggerMssql.java | 9 +- .../dbgit/mssql/DBRestoreUserMssql.java | 7 +- .../dbgit/mssql/DBRestoreViewMssql.java | 6 +- .../mssql/FactoryDBAdapterRestoreMssql.java | 2 +- .../mssql/FactoryDbConvertAdapterMssql.java | 7 +- .../dbgit/mysql/DBAdapterMySql.java | 18 +- .../dbgit/mysql/DBBackupAdapterMySql.java | 19 +- .../dbgit/mysql/DBRestoreSchemaMySql.java | 7 +- .../dbgit/mysql/DBRestoreTableDataMySql.java | 24 +- .../dbgit/mysql/DBRestoreTableMySql.java | 31 +- .../dbgit/mysql/DBRestoreUserMySql.java | 7 +- .../dbgit/mysql/DBRestoreViewMySql.java | 7 +- .../mysql/FactoryDBConvertAdapterMySql.java | 7 +- .../mysql/FactoryDBRestoreAdapterMySql.java | 2 +- .../converters/SchemaConverterMySql.java | 7 +- .../mysql/converters/TableConverterMySql.java | 36 +- .../mysql/converters/ViewConverterMySql.java | 7 +- .../dbgit/oracle/DBAdapterOracle.java | 210 ++-- .../dbgit/oracle/DBBackupAdapterOracle.java | 11 +- .../dbgit/oracle/DBRestoreFunctionOracle.java | 7 +- .../dbgit/oracle/DBRestorePackageOracle.java | 7 +- .../oracle/DBRestoreProcedureOracle.java | 7 +- .../dbgit/oracle/DBRestoreRoleOracle.java | 7 +- .../dbgit/oracle/DBRestoreSchemaOracle.java | 7 +- .../dbgit/oracle/DBRestoreSequenceOracle.java | 7 +- .../oracle/DBRestoreTableDataOracle.java | 59 +- .../dbgit/oracle/DBRestoreTableOracle.java | 859 ++++++++--------- .../dbgit/oracle/DBRestoreTriggerOracle.java | 7 +- .../dbgit/oracle/DBRestoreViewOracle.java | 7 +- .../oracle/FactoryDBAdapterRestoreOracle.java | 5 +- .../oracle/FactoryDbConvertAdapterOracle.java | 7 +- .../converters/TableConverterOracle.java | 36 +- .../dbgit/postgres/DBAdapterPostgres.java | 17 +- .../postgres/DBBackupAdapterPostgres.java | 21 +- .../postgres/DBRestoreFunctionPostgres.java | 207 ++-- .../postgres/DBRestoreProcedurePostgres.java | 9 +- .../dbgit/postgres/DBRestoreRolePostgres.java | 7 +- .../postgres/DBRestoreSchemaPostgres.java | 7 +- .../postgres/DBRestoreSequencePostgres.java | 8 +- .../postgres/DBRestoreTableDataPostgres.java | 55 +- .../postgres/DBRestoreTablePostgres.java | 51 +- .../postgres/DBRestoreTableSpacePostgres.java | 7 +- .../postgres/DBRestoreTriggerPostgres.java | 198 ++-- .../dbgit/postgres/DBRestoreUserPostgres.java | 7 +- .../dbgit/postgres/DBRestoreViewPostgres.java | 14 +- .../FactoryDBAdapterRestorePostgres.java | 2 +- .../FactoryDbConvertAdapterPostgres.java | 7 +- .../converters/TableConverterPostgresql.java | 48 +- .../fusionsoft/dbgit/utils/ConsoleWriter.java | 297 +++--- src/main/resources/lang/eng.yaml | 63 +- .../java/ru/fusionsoft/dbgit/DBGitTest.java | 31 +- .../dbgit/mssql/DBAdapterMssqlTest.java | 4 +- 96 files changed, 2508 insertions(+), 2182 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/App.java b/src/main/java/ru/fusionsoft/dbgit/App.java index d72e2c5..cc9f96a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/App.java +++ b/src/main/java/ru/fusionsoft/dbgit/App.java @@ -96,7 +96,11 @@ public static void main( String[] args ) throws Exception executeDbGitCommand(args); } catch (Exception e) { - ConsoleWriter.printlnRed(DBGitLang.getInstance().getValue("errors", "executionError") + ": " + e.getMessage()); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "executionError") + .withParams(e.getMessage()) + , 0 + ); LoggerUtil.getGlobalLogger().error(e.getMessage(), e); } finally { DBGitPath.clearTempDir(); diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 6355f4c..563154c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -51,16 +51,26 @@ public Connection getConnection() { connect.setAutoCommit(false); return connect; } else { - ConsoleWriter.println("Connection lost, trying to reconnect..."); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "dbAdapter", "connectionLost") + , messageLevel-1 + ); while (currentTry <= maxTriesCount) { TimeUnit.SECONDS.sleep(pauseTimeSeconds); currentTry++; - ConsoleWriter.println("Try " + currentTry); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "dbAdapter", "reconnectTry") + .withParams(String.valueOf(currentTry)) + , messageLevel + ); DBConnection conn = DBConnection.getInstance(false); if (conn.testingConnection()) { conn.flushConnection(); conn = DBConnection.getInstance(true); - ConsoleWriter.println("Successful reconnect"); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "dbAdapter", "reconnectTrySuccess") + , messageLevel + ); connect = conn.getConnect(); connect.setAutoCommit(false); return connect; @@ -102,9 +112,9 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { Set createdRoles = getRoles().values().stream().map(DBRole::getName).collect(Collectors.toSet()); // remove table indexes and constraints, which is step(-2) of restoreMetaObject(MetaTable) - ConsoleWriter.println(lang.getValue("general", "restore", "droppingTablesConstraints"), 1); + ConsoleWriter.println(lang.getValue("general", "restore", "droppingTablesConstraints"), messageLevel); for (IMetaObject table : tablesExists.sortFromDependencies()) { - ConsoleWriter.println(lang.getValue("general", "restore", "droppingTableConstraints").withParams(table.getName()), 2); + ConsoleWriter.println(lang.getValue("general", "restore", "droppingTableConstraints").withParams(table.getName()), messageLevel+1); getFactoryRestore().getAdapterRestore(DBGitMetaType.DBGitTable, this).restoreMetaObject(table, -2); } @@ -138,18 +148,15 @@ public void restoreDataBase(IMapMetaObject updateObjs) throws Exception { } // restore table constraints, which is step(-1) of restoreMetaObject(MetaTable) - ConsoleWriter.println(lang.getValue("general", "restore", "restoringTablesConstraints"), 2); + ConsoleWriter.println(lang.getValue("general", "restore", "restoringTablesConstraints"), messageLevel); for (IMetaObject table : tables.sortFromReferenced()) { getFactoryRestore().getAdapterRestore(DBGitMetaType.DBGitTable, this).restoreMetaObject(table, -1); } connect.commit(); } catch (Exception e) { - //TODO wont work with ExceptionDBGit*, cause they call System.exit(1) in ctor; - connect.rollback(); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "restoreError").toString(), e); } finally { - //connect.setAutoCommit(false); - } + } } @@ -221,23 +228,33 @@ private IMetaObject tryConvert(IMetaObject obj) throws Exception { } } else { if ( checkContainsNativeFields(obj)) { - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "restore", "unsupportedTypes").withParams(obj.getName())); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "restore", "unsupportedTypes") + .withParams(obj.getName()) + , messageLevel + ); } } IDBConvertAdapter convertAdapter = getConvertAdapterFactory().getConvertAdapter(obj.getType().getValue()); if (convertAdapter != null) return convertAdapter.convert(getDbType(), getDbVersion(), obj); else { - throw new Exception(MessageFormat.format( - "Could not get convert adapter for {0} ({1} {2} -> {3})", - obj.getName(), obj.getDbType().toString(), obj.getDbVersion(), getDbVersionNumber() - )); + String msg = DBGitLang.getInstance().getValue("errors", "convert", "cannotFindAdapter").withParams( + obj.getName(), obj.getDbType().toString(), obj.getDbVersion() + , getDbType().toString() + , String.valueOf(getDbVersionNumber()) + ); + throw new Exception(msg); } } private void createSchemaIfNeed(IMetaObject obj, Set createdSchemas) throws Exception { String schemaName = getSchemaSynonymName(obj); if(schemaName == null){ - ConsoleWriter.detailsPrintlnRed(MessageFormat.format("Object {0} schema is null", obj.getName())); + ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance() + .getValue("errors", "adapter", "nullSchema") + .withParams(obj.getName()) + , messageLevel + ); return; } if (!createdSchemas.contains(schemaName)) { diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java index b567e6d..f872f5d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java @@ -137,25 +137,30 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { dropList.addAll(dbDroppingBackupsDeps); List dropListSorted = new SortedListMetaObject(dropList).sortFromDependencies(); - ConsoleWriter.println(DBGitLang.getInstance() + if(dropList.size() > 0) ConsoleWriter.println(DBGitLang.getInstance() .getValue("general", "backup", "rewritingBackups") .withParams( String.valueOf(dbDroppingBackups.size()), String.valueOf(dbDroppingBackupsDeps.size()) - ), 2 + ), messageLevel-1 ); - //dropListSorted.forEach( x -> ConsoleWriter.detailsPrintLnColor( x.getName(), 3, Ansi.FColor.MAGENTA)); - //drop backups in one place for(IMetaObject imo : dropListSorted){ - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "droppingBackup").withParams(imo.getName()), 3); - + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "droppingBackup").withParams(imo.getName()), messageLevel); dropIfExists(imo, stLog); ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } + if(dbToBackup.size() > 0) ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "backup", "creatingBackups") + .withParams( + String.valueOf(dbToBackup.size()) + ), messageLevel-1 + ); + + //create backups for(IMetaObject imo : dbToBackup.getSortedList().sortFromReferenced()){ backupDBObject(imo); diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBRestoreAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBRestoreAdapter.java index 4b8f1ee..4680c27 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBRestoreAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBRestoreAdapter.java @@ -18,7 +18,9 @@ public abstract class DBRestoreAdapter implements IDBAdapterRestoreMetaData { protected IDBAdapter adapter = null; protected DBGitLang lang = DBGitLang.getInstance(); - + public static int messageLevel = 3; + + public void setAdapter(IDBAdapter adapter) { this.adapter = adapter; } diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java index bf805b4..ecad994 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java @@ -36,6 +36,7 @@ public interface IDBAdapter { public static final int MAX_ROW_COUNT_FETCH = 10000; public static final int LIMIT_FETCH = 1; public static final int NOLIMIT_FETCH = 2; + public static final int messageLevel = 2; public void setConnection(Connection conn); diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBBackupAdapter.java index 0fbe1a3..dd6474b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBBackupAdapter.java @@ -11,8 +11,9 @@ public interface IDBBackupAdapter { - public static final String PREFIX = "BACKUP$"; - + public static final String PREFIX = "BACKUP$"; + static int messageLevel = 3; + public void setAdapter(IDBAdapter adapter); public IDBAdapter getAdapter(); diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBConvertAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBConvertAdapter.java index aa11dab..ac1930e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBConvertAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBConvertAdapter.java @@ -7,5 +7,6 @@ import ru.fusionsoft.dbgit.meta.MetaTable; public interface IDBConvertAdapter { + public static int messageLevel = 2; public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) throws ExceptionDBGit; } diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/IFactoryDBAdapterRestoteMetaData.java b/src/main/java/ru/fusionsoft/dbgit/adapters/IFactoryDBAdapterRestoteMetaData.java index de1b8ff..a66bf9d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/IFactoryDBAdapterRestoteMetaData.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/IFactoryDBAdapterRestoteMetaData.java @@ -6,5 +6,6 @@ import ru.fusionsoft.dbgit.meta.IDBGitMetaType; public interface IFactoryDBAdapterRestoteMetaData { + static int messageLevel = 1; public IDBAdapterRestoreMetaData getAdapterRestore(IDBGitMetaType tp, IDBAdapter adapter); } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java index 8b18b72..592e14e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdAdd.java @@ -79,21 +79,23 @@ public void execute(CommandLine cmdLine) throws Exception { DBGitConfig.getInstance().setValue("CURRENT_OBJECT", obj.getName().replace(".csv", ".tbl")); Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "add", "processingObject") + " " + obj.getName()); - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "add", "savingToFile"), 2); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "add", "processingObject") + .withParams(obj.getName()) + , messageLevel + ); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "add", "savingToFile"), messageLevel+1); //TODO obj.saveToFile(); ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); - ConsoleWriter.detailsPrint(getLang().getValue("general", "addToGit"), 2); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "addToGit"), messageLevel+1); countSave += obj.addToGit(); ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); Long diff = timestampAfter.getTime() - timestampBefore.getTime(); - ConsoleWriter.detailsPrint(getLang().getValue("general", "time").withParams(diff.toString()), 2); - ConsoleWriter.detailsPrintLn(""); + ConsoleWriter.detailsPrint(getLang().getValue("general", "time").withParams(diff.toString())); index.addItem(obj); @@ -116,7 +118,7 @@ public void execute(CommandLine cmdLine) throws Exception { isFirstPortion = (DBGitConfig.getInstance().getInteger("core", "CURRENT_PORTION", 0) == 0); while (gmdm.loadNextPortion((MetaTable) obj)) { - ConsoleWriter.detailsPrint(getLang().getValue("general", "add", "writing").toString(), 2); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "add", "writing").toString(), messageLevel+1); try { //gmdm.getCurrent().serialize(out); Integer count = 0; @@ -137,7 +139,6 @@ public void execute(CommandLine cmdLine) throws Exception { } catch (Exception e) { - e.printStackTrace(); throw new ExceptionDBGit(e); } } @@ -155,8 +156,8 @@ public void execute(CommandLine cmdLine) throws Exception { index.saveDBIndex(); index.addToGit(); } else { - ConsoleWriter.printlnRed(getLang().getValue("errors", "add", "cantFindObjectInDb").withParams(nameObj)); + ConsoleWriter.printlnRed(getLang().getValue("errors", "add", "cantFindObjectInDb").withParams(nameObj), messageLevel); } - ConsoleWriter.println(getLang().getValue("general", "done")); + ConsoleWriter.println(getLang().getValue("general", "done"), messageLevel); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java index f0ac2b6..c833657 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java @@ -9,9 +9,9 @@ import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.revwalk.RevWalk; import ru.fusionsoft.dbgit.core.DBGit; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import java.text.MessageFormat; public class CmdCheckout implements IDBGitCommand { @@ -62,12 +62,16 @@ public void execute(CommandLine cmdLine) throws Exception { String headName = head.getName(); String message = walk.parseCommit(head.getObjectId()).getShortMessage(); - ConsoleWriter.printlnGreen(MessageFormat.format( - "{0} ({1}) {2}", - !branch.equals(headNumber) ? branch + ": " + headName : headNumber, - headName, - message - )); + ConsoleWriter.printlnGreen(DBGitLang.getInstance() + .getValue("general", "checkout", "printBranchAndCommit") + .withParams( + !branch.equals(headNumber) ? branch + ": " + headName : headNumber, + headName, + message + ) + , messageLevel + ); + } return; } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdCommit.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdCommit.java index 6c006be..e5fa306 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdCommit.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdCommit.java @@ -54,7 +54,7 @@ public void execute(CommandLine cmdLine) throws Exception { checkVersion(); - ConsoleWriter.println(getLang().getValue("general", "commit", "commiting")); + ConsoleWriter.println(getLang().getValue("general", "commit", "commiting"), messageLevel); DBGitIndex.getInctance().addLinkToGit(); DBGitIndex.getInctance().addIgnoreToGit(); DBGit.getInstance().gitCommit(cmdLine.hasOption("a"), msg, filePath); diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java index a063853..c8759f7 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java @@ -1,108 +1,124 @@ -package ru.fusionsoft.dbgit.command; - -import java.sql.Timestamp; -import java.util.Map; - -import org.apache.commons.cli.CommandLine; -import org.apache.commons.cli.Options; - -import ru.fusionsoft.dbgit.core.DBGit; -import ru.fusionsoft.dbgit.core.DBGitIndex; -import ru.fusionsoft.dbgit.core.DBGitPath; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.GitMetaDataManager; -import ru.fusionsoft.dbgit.meta.IMapMetaObject; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -public class CmdDump implements IDBGitCommand { - private Options opts = new Options(); - - public CmdDump() { - opts.addOption("a", false, getLang().getValue("help", "dump-a").toString()); - opts.addOption("f", false, getLang().getValue("help", "dump-f").toString()); - opts.addOption("u", false, getLang().getValue("help", "dump-u").toString()); - } - - public String getCommandName() { - return "dump"; - } - - public String getParams() { - return ""; - } - - public String getHelperInfo() { - return getLang().getValue("help", "dump").toString(); - } - - public Options getOptions() { - return opts; - } - @Override - public void execute(CommandLine cmdLine) throws Exception { - Boolean isAddToGit = cmdLine.hasOption('a'); - Boolean isAllDump = cmdLine.hasOption('f'); - - ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); - - GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); - - DBGitIndex index = DBGitIndex.getInctance(); - - if (!cmdLine.hasOption("u")) - checkVersion(); - - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "dump", "checking")); - - IMapMetaObject fileObjs = gmdm.loadFileMetaDataForce(); - - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "dump", "dumping")); - - for (IMetaObject obj : fileObjs.values()) { - Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "dump", "processing").withParams(obj.getName())); - String hash = obj.getHash(); - ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "hash") + ": " + hash + "\n", 2); - - ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "loading") + "\n", 2); - if (!gmdm.loadFromDB(obj)) { - ConsoleWriter.println(getLang().getValue("general", "dump", "cantFindInDb").withParams(obj.getName())); - continue; - } - ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "dbHash") + ": " + obj.getHash() + "\n", 2); - - if (isAllDump || !obj.getHash().equals(hash)) { - if (!obj.getHash().equals(hash)) - ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "hashesDifferent"), 2); - else - ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "fSwitchFound"), 2); - //сохранили файл если хеш разный - obj.saveToFile(); - ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); - ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "addToIndex"), 2); - index.addItem(obj); - ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); - - if (isAddToGit) { - ConsoleWriter.detailsPrint(getLang().getValue("general", "addToGit"), 2); - obj.addToGit(); - ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); - } - } else { - ConsoleWriter.detailsPrint(getLang().getValue("general", "dump", "hashesMatch") + "\n", 2); - } - Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); - Long diff = timestampAfter.getTime() - timestampBefore.getTime(); - ConsoleWriter.detailsPrint(getLang().getValue("general", "time").withParams(diff.toString()), 2); - ConsoleWriter.detailsPrintLn(""); - } - - index.saveDBIndex(); - if (isAddToGit) { - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "addToGit")); - index.addToGit(); - } - ConsoleWriter.println(getLang().getValue("general", "done")); - } -} +package ru.fusionsoft.dbgit.command; + +import java.sql.Timestamp; +import java.util.Map; + +import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.Options; + +import ru.fusionsoft.dbgit.core.DBGit; +import ru.fusionsoft.dbgit.core.DBGitIndex; +import ru.fusionsoft.dbgit.core.DBGitPath; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.GitMetaDataManager; +import ru.fusionsoft.dbgit.meta.IMapMetaObject; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +public class CmdDump implements IDBGitCommand { + private Options opts = new Options(); + + public CmdDump() { + opts.addOption("a", false, getLang().getValue("help", "dump-a").toString()); + opts.addOption("f", false, getLang().getValue("help", "dump-f").toString()); + opts.addOption("u", false, getLang().getValue("help", "dump-u").toString()); + } + + public String getCommandName() { + return "dump"; + } + + public String getParams() { + return ""; + } + + public String getHelperInfo() { + return getLang().getValue("help", "dump").toString(); + } + + public Options getOptions() { + return opts; + } + @Override + public void execute(CommandLine cmdLine) throws Exception { + Boolean isAddToGit = cmdLine.hasOption('a'); + Boolean isAllDump = cmdLine.hasOption('f'); + + ConsoleWriter.setDetailedLog(cmdLine.hasOption("v")); + + GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); + + DBGitIndex index = DBGitIndex.getInctance(); + + if (!cmdLine.hasOption("u")) + checkVersion(); + + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "checking"), messageLevel); + + IMapMetaObject fileObjs = gmdm.loadFileMetaDataForce(); + + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "dumping"), messageLevel); + + for (IMetaObject obj : fileObjs.values()) { + Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "processing") + .withParams(obj.getName()) + , messageLevel + ); + String hash = obj.getHash(); + + ConsoleWriter.detailsPrintln(DBGitLang.getInstance() + .getValue("general", "dump", "hash") + .withParams(hash) + , messageLevel+1 + ); + + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "loading"), messageLevel+1); + if (!gmdm.loadFromDB(obj)) { + ConsoleWriter.println(getLang().getValue("general", "dump", "cantFindInDb") + .withParams(obj.getName()) + , messageLevel + ); + continue; + } + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "dbHash") + .withParams(obj.getHash()), messageLevel+1 + ); + + if (isAllDump || !obj.getHash().equals(hash)) { + if (!obj.getHash().equals(hash)) + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "hashesDifferent") + , messageLevel+1 + ); + else + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "fSwitchFound") + , messageLevel+1 + ); + //сохранили файл если хеш разный + obj.saveToFile(); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "addToIndex"), messageLevel+1); + index.addItem(obj); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); + + if (isAddToGit) { + ConsoleWriter.detailsPrintln(getLang().getValue("general", "addToGit"), messageLevel+1); + obj.addToGit(); + ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); + } + } else { + ConsoleWriter.detailsPrintln(getLang().getValue("general", "dump", "hashesMatch"), messageLevel+1); + } + Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); + Long diff = timestampAfter.getTime() - timestampBefore.getTime(); + ConsoleWriter.detailsPrint(getLang().getValue("general", "time").withParams(diff.toString())); + } + + index.saveDBIndex(); + if (isAddToGit) { + ConsoleWriter.detailsPrintln(getLang().getValue("general", "addToGit"), messageLevel+1); + index.addToGit(); + } + ConsoleWriter.println(getLang().getValue("general", "done"), messageLevel); + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdFetch.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdFetch.java index 2779dc5..f7cf5c0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdFetch.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdFetch.java @@ -37,7 +37,7 @@ public void execute(CommandLine cmdLine) throws Exception { String[] args = cmdLine.getArgs(); String remote = ""; - ConsoleWriter.println(getLang().getValue("general", "fetch", "fetching")); + ConsoleWriter.println(getLang().getValue("general", "fetch", "fetching"), messageLevel); if (args.length == 1) { remote = args[0]; diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdHelp.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdHelp.java index fedfc7d..e146cf4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdHelp.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdHelp.java @@ -31,7 +31,7 @@ public Options getOptions() { } @Override public void execute(CommandLine cmdLine) throws Exception { - ConsoleWriter.println(getLang().getValue("help", "common")); + ConsoleWriter.println(getLang().getValue("help", "common"), messageLevel); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java index 4dcb2da..bac371f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java @@ -46,7 +46,7 @@ public void execute(CommandLine cmdLine) throws Exception { DBConnection conn = DBConnection.getInstance(false); if(cmdLine.hasOption("ls")) { - ConsoleWriter.printlnGreen(DBConnection.loadFileDBLink(new Properties())); + ConsoleWriter.printlnGreen(DBConnection.loadFileDBLink(new Properties()), messageLevel); return; } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java index b1a64af..8488951 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java @@ -61,7 +61,7 @@ public void execute(CommandLine cmdLine) throws Exception { adapter = AdapterFactory.createAdapter(); adapter.setDumpSqlCommand(scriptOutputStream, toMakeChanges); } catch (NullPointerException e) { - ConsoleWriter.println(getLang().getValue("errors", "restore", "cantConnect")); + ConsoleWriter.println(getLang().getValue("errors", "restore", "cantConnect"), messageLevel); System.exit(0); } @@ -190,7 +190,7 @@ public void execute(CommandLine cmdLine) throws Exception { } } } - ConsoleWriter.println(getLang().getValue("general", "done")); + ConsoleWriter.println(getLang().getValue("general", "done"), messageLevel); } private boolean checkNeedsRestore(IMetaObject obj){ diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java index e9402c8..9844ccf 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java @@ -54,7 +54,7 @@ public void execute(CommandLine cmdLine) throws Exception { DBGitIndex index = DBGitIndex.getInctance(); - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "rm", "checking")); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "rm", "checking"), messageLevel+1); GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); IMapMetaObject dbObjs = gmdm.loadFileMetaDataForce(); @@ -64,12 +64,15 @@ public void execute(CommandLine cmdLine) throws Exception { Integer countDelete = 0; - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "rm", "deleting")); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "rm", "deleting"), messageLevel+1); for (ItemIndex idxItem : index.getTreeItems().values()) { if (maskAdd.match(idxItem.getName())) { Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); - ConsoleWriter.detailsPrintLn(getLang().getValue("general", "rm", "processing").withParams(idxItem.getName())); - ConsoleWriter.detailsPrint(getLang().getValue("general", "rm", "removingFromGit"), 2); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "rm", "processing") + .withParams(idxItem.getName()) + , messageLevel+1 + ); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "rm", "removingFromGit"), messageLevel+2); IMetaObject metaObject = dbObjs.get(idxItem.getName()); if(metaObject != null){ @@ -81,18 +84,18 @@ public void execute(CommandLine cmdLine) throws Exception { } ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); - ConsoleWriter.detailsPrint(getLang().getValue("general", "rm", "markingToDelete") + " ... ", 2); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "rm", "markingToDelete") + " ... ", messageLevel+2); index.markItemToDelete(metaObject); ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); Long diff = timestampAfter.getTime() - timestampBefore.getTime(); - ConsoleWriter.detailsPrint(getLang().getValue("general", "time").withParams(diff.toString()), 2); + ConsoleWriter.detailsPrint(getLang().getValue("general", "time").withParams(diff.toString())); } } if (forgetImmediately) { - ConsoleWriter.detailsPrint(getLang().getValue("general", "rm", "removingFromIndex"), 2); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "rm", "removingFromIndex"), messageLevel+1); index.getTreeItems().values().stream().filter(ItemIndex::getIsDelete).collect(Collectors.toList()).forEach(x->index.getTreeItems().remove(x.getName())); index.saveDBIndex(); index.addToGit(); @@ -100,7 +103,7 @@ public void execute(CommandLine cmdLine) throws Exception { } if (cmdLine.hasOption("db")) { - ConsoleWriter.detailsPrint(getLang().getValue("general", "rm", "removingFromDb"), 2); + ConsoleWriter.detailsPrintln(getLang().getValue("general", "rm", "removingFromDb"), messageLevel+1); gmdm.deleteDataBase(deleteObjs, true); ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); } @@ -109,9 +112,9 @@ public void execute(CommandLine cmdLine) throws Exception { index.saveDBIndex(); index.addToGit(); } else { - ConsoleWriter.printlnRed(getLang().getValue("errors", "rm", "cantFindFile").withParams(nameObj)); + ConsoleWriter.printlnRed(getLang().getValue("errors", "rm", "cantFindFile").withParams(nameObj), messageLevel+1); } - ConsoleWriter.println(getLang().getValue("general", "done")); + ConsoleWriter.println(getLang().getValue("general", "done"), messageLevel); } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdStatus.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdStatus.java index daebca4..a5feb01 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdStatus.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdStatus.java @@ -51,23 +51,23 @@ public void execute(CommandLine cmdLine) throws Exception { DBGit dbGit = DBGit.getInstance(); boolean hasConflicts = DBGitIndex.getInctance().hasConflicts(); String repoVersion = DBGitIndex.getInctance().getRepoVersion(); - ConsoleWriter.println(getLang().getValue("general", "status", "repVersion").withParams(repoVersion)); - ConsoleWriter.println(getLang().getValue("general", "status", "dbgitVersion").withParams(DBGitIndex.VERSION)); + ConsoleWriter.println(getLang().getValue("general", "status", "repVersion").withParams(repoVersion), messageLevel); + ConsoleWriter.println(getLang().getValue("general", "status", "dbgitVersion").withParams(DBGitIndex.VERSION), messageLevel); if (!DBGitIndex.getInctance().isCorrectVersion()) - ConsoleWriter.println(getLang().getValue("general", "status", "differentVersions")); + ConsoleWriter.println(getLang().getValue("general", "status", "differentVersions"), messageLevel); if (hasConflicts) { - ConsoleWriter.println(getLang().getValue("general", "status", "conflicts")); + ConsoleWriter.println(getLang().getValue("general", "status", "conflicts"), messageLevel); } SchemaSynonym ss = SchemaSynonym.getInstance(); if (ss.getCountSynonym() > 0) { - ConsoleWriter.printlnGreen(getLang().getValue("general", "status", "usedSynonyms")); - ConsoleWriter.printlnGreen(getLang().getValue("general", "status", "synSchema")); + ConsoleWriter.printlnGreen(getLang().getValue("general", "status", "usedSynonyms"), messageLevel); + ConsoleWriter.printlnGreen(getLang().getValue("general", "status", "synSchema"), messageLevel); for (Entry el : ss.getMapSchema().entrySet()) { - ConsoleWriter.println(el.getKey() + " - " + el.getValue()); + ConsoleWriter.println(el.getKey() + " - " + el.getValue(), messageLevel+1); } } @@ -102,40 +102,40 @@ public void execute(CommandLine cmdLine) throws Exception { addedObjs.put(fileObjs.get(name)); } - ConsoleWriter.println(getLang().getValue("general", "status", "changesToCommit")); + ConsoleWriter.println(getLang().getValue("general", "status", "changesToCommit"), messageLevel); for(IMetaObject obj : addedObjs.values()) { - printObect(obj, FColor.GREEN, 1); + printObect(obj, FColor.GREEN, messageLevel+1); } - ConsoleWriter.println(" "); + ConsoleWriter.printLineBreak(); - ConsoleWriter.println(getLang().getValue("general", "status", "notStaged")); + ConsoleWriter.println(getLang().getValue("general", "status", "notStaged"), messageLevel); for(IMetaObject obj : changeObjs.values()) { printObect(obj, FColor.RED, 1); } - ConsoleWriter.println(" "); - + ConsoleWriter.printLineBreak(); + - ConsoleWriter.println(getLang().getValue("general", "status", "untracked")); + ConsoleWriter.println(getLang().getValue("general", "status", "untracked"), messageLevel); for (String name : dbObjs.keySet()) { if (!fileObjs.containsKey(name)) { - ConsoleWriter.println(name, 1); + ConsoleWriter.println(name, messageLevel+1); } } - ConsoleWriter.println(" "); + ConsoleWriter.printLineBreak(); - ConsoleWriter.println(getLang().getValue("general", "status", "localNotStaged")); + ConsoleWriter.println(getLang().getValue("general", "status", "localNotStaged"), messageLevel); for (String modified : DBGit.getInstance().getModifiedFiles()) { - ConsoleWriter.printlnColor(modified, FColor.RED, 1); + ConsoleWriter.printlnColor(modified, FColor.RED, messageLevel+1); } - ConsoleWriter.println(" "); + ConsoleWriter.printLineBreak(); - ConsoleWriter.println(getLang().getValue("general", "status", "localToCommit")); + ConsoleWriter.println(getLang().getValue("general", "status", "localToCommit"), messageLevel); for (String modified : DBGit.getInstance().getChanged()) { - ConsoleWriter.printlnColor(modified, FColor.GREEN, 1); + ConsoleWriter.printlnColor(modified, FColor.GREEN , messageLevel+1); } - ConsoleWriter.println(" "); + ConsoleWriter.printLineBreak(); } public void printObect(IMetaObject obj, FColor color, Integer level) { diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdSynonymSchema.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdSynonymSchema.java index e1e41a9..b4febfe 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdSynonymSchema.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdSynonymSchema.java @@ -39,9 +39,9 @@ public void execute(CommandLine cmdLine) throws Exception { Boolean isShow = cmdLine.hasOption('s'); if (isShow) { - ConsoleWriter.printlnGreen(getLang().getValue("general", "status", "synSchema")); + ConsoleWriter.printlnGreen(getLang().getValue("general", "status", "synSchema"), messageLevel); for (Entry el : ss.getMapSchema().entrySet()) { - ConsoleWriter.println(el.getKey() + " - " + el.getValue()); + ConsoleWriter.println(el.getKey() + " - " + el.getValue(), messageLevel+1); } return ; } @@ -66,6 +66,6 @@ public void execute(CommandLine cmdLine) throws Exception { } ss.saveFile(); - ConsoleWriter.println(getLang().getValue("general", "done")); + ConsoleWriter.println(getLang().getValue("general", "done"), messageLevel); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdValid.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdValid.java index 7e7c241..c5ba535 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdValid.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdValid.java @@ -43,9 +43,9 @@ public void execute(CommandLine cmdLine) throws Exception { //возможно за списком файлов нужно будет сходить в гит индекс try { Map fileObjs = gmdm.loadFileMetaData(); - ConsoleWriter.printlnGreen(getLang().getValue("general", "valid", "allOk")); + ConsoleWriter.printlnGreen(getLang().getValue("general", "valid", "allOk"), messageLevel); } catch (Exception e) { - ConsoleWriter.printlnRed(e.getMessage()); + ConsoleWriter.printlnRed(e.getMessage(), messageLevel); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/IDBGitCommand.java b/src/main/java/ru/fusionsoft/dbgit/command/IDBGitCommand.java index 0554dff..d7e2187 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/IDBGitCommand.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/IDBGitCommand.java @@ -15,6 +15,8 @@ * */ public interface IDBGitCommand { + public static int messageLevel = 0; + public void execute(CommandLine cmdLine) throws Exception; public String getCommandName(); diff --git a/src/main/java/ru/fusionsoft/dbgit/command/RequestCmd.java b/src/main/java/ru/fusionsoft/dbgit/command/RequestCmd.java index ac12e4f..9c876a4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/RequestCmd.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/RequestCmd.java @@ -125,7 +125,7 @@ public void printHelpAboutCommand(String command) throws Exception { public static void main( String[] args ) throws Exception { - ConsoleWriter.println( "dbgit utils - Hello!"); + ConsoleWriter.println( "dbgit utils - Hello!", 0); //configureLogback(); @@ -171,9 +171,16 @@ public static void main( String[] args ) throws Exception - ConsoleWriter.println( "execute command success!"); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "commandSuccess") + , 0 + ); } catch (Exception e) { - ConsoleWriter.printlnRed("Error execute dbgit: "+e.getMessage()); + ConsoleWriter.printlnRed(DBGitLang.getInstance() + .getValue("errors", "cmdException") + .withParams(e.getMessage()) + , 0 + ); LoggerUtil.getGlobalLogger().error(e.getMessage(), e); } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBConnection.java b/src/main/java/ru/fusionsoft/dbgit/core/DBConnection.java index a33cf79..d5d045f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBConnection.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBConnection.java @@ -22,6 +22,7 @@ */ public class DBConnection { private static DBConnection dbGitConnection = null; + private static int messageLevel = 1; private Connection connect = null; private Logger logger = LoggerUtil.getLogger(this.getClass()); private DBGitLang lang = DBGitLang.getInstance(); @@ -68,12 +69,12 @@ public boolean testingConnection() { String url = loadFileDBLink(props); Connection conTest = DriverManager.getConnection(url, props); - ConsoleWriter.printlnGreen(lang.getValue("general", "link", "connectionEstablished")); + ConsoleWriter.printlnGreen(lang.getValue("general", "link", "connectionEstablished"), messageLevel); conTest.close(); conTest = null; return true; } catch(Exception e) { - ConsoleWriter.printlnRed(lang.getValue("errors", "link", "cantConnect") + ": " + e.getMessage()); + ConsoleWriter.printlnRed(lang.getValue("errors", "link", "cantConnect").withParams(e.getMessage()), messageLevel); return false; } } @@ -81,12 +82,12 @@ public boolean testingConnection() { public boolean testingConnection(String url, Properties props) { try { Connection conTest = DriverManager.getConnection(url, props); - ConsoleWriter.printlnGreen(lang.getValue("general", "link", "connectionEstablished")); + ConsoleWriter.printlnGreen(lang.getValue("general", "link", "connectionEstablished"), messageLevel); conTest.close(); conTest = null; return true; } catch(Exception e) { - ConsoleWriter.printlnRed(lang.getValue("errors", "link", "cantConnect") + ": " + e.getMessage()); + ConsoleWriter.printlnRed(lang.getValue("errors", "link", "cantConnect").withParams(e.getMessage()), messageLevel); return false; } } @@ -115,10 +116,10 @@ public static void createFileDBLink(String url, Properties props, boolean isDefa writer.write(key+"="+ props.getProperty(key)+"\n"); } writer.close(); - ConsoleWriter.detailsPrintLn( + ConsoleWriter.detailsPrintln( DBGitLang.getInstance().getValue("general", "link", "dblinkCreated") .withParams(DBGitPath.getFullPath(DBGitPath.DB_LINK_FILE)) - , 1 + , messageLevel ); } catch(Exception e) { throw new ExceptionDBGit(e); @@ -146,4 +147,8 @@ public static String loadFileDBLink(Properties props) throws ExceptionDBGit { throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "fileLoadError").withParams(DBGitPath.DB_LINK_FILE), e); } } + + public static boolean hasInstance(){ + return dbGitConnection != null; + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index 6c058c4..d9e0c11 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -32,6 +32,8 @@ public class DBGit { private static DBGit dbGit = null; private Repository repository; private Git git; + private static int messageLevel = 0; + private DBGit() throws ExceptionDBGit { try { @@ -207,7 +209,7 @@ public void gitCommit(boolean existsSwitchA, String msg, String path) throws Exc for (IMetaObject obj : fileObjs.values()) { String hash = obj.getHash(); if (!gmdm.loadFromDB(obj)) { - ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "commit", "cantFindObject")); + ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "commit", "cantFindObject"), messageLevel); obj.removeFromGit(); index.markItemToDelete(obj); index.saveDBIndex(); @@ -241,8 +243,12 @@ public void gitCommit(boolean existsSwitchA, String msg, String path) throws Exc res = git.commit().setAll(existsSwitchA).setOnly(DBGitPath.DB_GIT_PATH + "/" + path).call(); } } - ConsoleWriter.printlnGreen(DBGitLang.getInstance().getValue("general", "commit", "commit") + ": " + res.getName()); - ConsoleWriter.printlnGreen(res.getAuthorIdent().getName() + "<" + res.getAuthorIdent().getEmailAddress() + ">, " + res.getAuthorIdent().getWhen()); + ConsoleWriter.printlnGreen(DBGitLang.getInstance().getValue("general", "commit", "commit") + ": " + res.getName() + , messageLevel + ); + ConsoleWriter.printlnGreen(res.getAuthorIdent().getName() + "<" + res.getAuthorIdent().getEmailAddress() + ">, " + res.getAuthorIdent().getWhen() + , messageLevel + ); } catch (Exception e) { throw new ExceptionDBGit(e); @@ -251,13 +257,21 @@ public void gitCommit(boolean existsSwitchA, String msg, String path) throws Exc public void gitCheckout(String branch, String commit, boolean isNewBranch) throws ExceptionDBGit { try { - ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("general", "checkout", "do")); - ConsoleWriter.detailsPrintLnColor(DBGitLang.getInstance().getValue("general", "checkout", "toCreateBranch") + ": " + isNewBranch, 1, Ansi.FColor.GREEN); - ConsoleWriter.detailsPrintLnColor(DBGitLang.getInstance().getValue("general", "checkout", "branchName") + ": " + branch, 1, Ansi.FColor.GREEN); - if (commit != null) - ConsoleWriter.detailsPrintLnColor(DBGitLang.getInstance().getValue("general", "checkout", "commitName") + ": " + commit, 1, Ansi.FColor.GREEN); - - + ConsoleWriter.detailsPrintln(DBGitLang.getInstance().getValue("general", "checkout", "do"), messageLevel); + ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "checkout", "toCreateBranch") + .withParams(String.valueOf(isNewBranch)) + , messageLevel+1 + ); + ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "checkout", "branchName") + .withParams(branch) + , messageLevel+1 + ); + if (commit != null){ + ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "checkout", "commitName") + .withParams(commit) + , messageLevel+1 + ); + } Ref result; if (git.getRepository().findRef(branch) != null || isNewBranch) { @@ -276,10 +290,10 @@ public void gitCheckout(String branch, String commit, boolean isNewBranch) throw result = checkout.call(); try(RevWalk walk = new RevWalk(repository)){ - ConsoleWriter.detailsPrintLnColor(MessageFormat.format("{0}: {1}" - , DBGitLang.getInstance().getValue("general", "checkout", "commitMessage") - , walk.parseCommit(repository.getAllRefs().get("HEAD").getObjectId()).getShortMessage() - ), 1, Ansi.FColor.GREEN); + ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "checkout", "commitMessage") + .withParams(walk.parseCommit(repository.getAllRefs().get("HEAD").getObjectId()).getShortMessage()) + , messageLevel+1 + ); } @@ -337,7 +351,10 @@ public void gitPull(String remote, String remoteBranch) throws ExceptionDBGit { , 1 ); } catch (Exception e) { - ConsoleWriter.println("Repo is empty!"); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "pull", "emptyGitRepository") + , 0 + ); //throw new ExceptionDBGit(e); } } @@ -346,29 +363,56 @@ public void gitPush(String remoteName) throws ExceptionDBGit { try { git.log().call(); } catch (Exception e) { - ConsoleWriter.println("No commits found!"); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "noCommitsFound") + , messageLevel + ); return; } try { - ConsoleWriter.detailsPrintLn("Entered to gitPush"); - ConsoleWriter.detailsPrintLn("remoteName: " + (remoteName.equals("") ? Constants.DEFAULT_REMOTE_NAME : remoteName)); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "remoteName") + .withParams((remoteName.equals("") ? Constants.DEFAULT_REMOTE_NAME : remoteName)) + , messageLevel+1 + ); Iterable result = git.push() .setCredentialsProvider(getCredentialsProviderByName(remoteName.equals("") ? Constants.DEFAULT_REMOTE_NAME : remoteName)) .setRemote(remoteName.equals("") ? Constants.DEFAULT_REMOTE_NAME : remoteName).call(); - ConsoleWriter.detailsPrintLn("Push called "); + ConsoleWriter.detailsPrintln("Push called ", messageLevel); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "called") + , messageLevel+1 + ); result.forEach(pushResult -> { - if (pushResult == null) - ConsoleWriter.detailsPrintLn("Push result is null!!! "); - pushResult.toString(); + if (pushResult == null){ + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "nullResult") + , 1 + ); + } else { + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "callResult") + .withParams(pushResult.toString()) + , messageLevel+1 + ); + } for (RemoteRefUpdate res : pushResult.getRemoteUpdates()) { - if (res.getStatus() == RemoteRefUpdate.Status.UP_TO_DATE) - ConsoleWriter.println("Everything up-to-date"); + if (res.getStatus() == RemoteRefUpdate.Status.UP_TO_DATE){ + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "upToDate") + , 1 + ); + } else { - ConsoleWriter.println(res.toString()); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "result") + .withParams(res.toString()) + , 1 + ); } } }); @@ -392,7 +436,7 @@ public static void gitInit(String dirPath) throws ExceptionDBGit { init.call(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "init", "created")); + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "init", "created"), messageLevel); } catch (Exception e) { throw new ExceptionDBGit(e); @@ -411,7 +455,7 @@ public static void gitClone(String link, String remoteName, File directory) thro cc.call(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "clone", "cloned")); + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "clone", "cloned"), messageLevel); } catch (Exception e) { throw new ExceptionDBGit(e); @@ -423,7 +467,7 @@ public void gitRemote(String command, String name, String uri) throws ExceptionD try { switch (command) { case "" : { - git.remoteList().call().forEach(remote -> ConsoleWriter.println(remote.getName())); + git.remoteList().call().forEach(remote -> ConsoleWriter.println(remote.getName(), messageLevel+1)); break; } @@ -433,7 +477,7 @@ public void gitRemote(String command, String name, String uri) throws ExceptionD remote.setUri(new URIish(uri)); remote.call(); - ConsoleWriter.printlnGreen(DBGitLang.getInstance().getValue("general", "remote", "added")); + ConsoleWriter.printlnGreen(DBGitLang.getInstance().getValue("general", "remote", "added"), messageLevel); break; } @@ -443,12 +487,12 @@ public void gitRemote(String command, String name, String uri) throws ExceptionD remote.setName(name); remote.call(); - ConsoleWriter.printlnGreen(DBGitLang.getInstance().getValue("general", "remote", "removed")); + ConsoleWriter.printlnGreen(DBGitLang.getInstance().getValue("general", "remote", "removed"), messageLevel); break; } - default : ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "remote", "unknown")); + default : ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "remote", "unknown"), messageLevel); } } catch (Exception e) { @@ -462,7 +506,7 @@ public void gitReset(String mode) throws ExceptionDBGit { git.reset().call(); else git.reset().setMode(ResetType.valueOf(mode)).call(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "done")); + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "done"), messageLevel); } catch (Exception e) { throw new ExceptionDBGit(e); } @@ -480,16 +524,23 @@ public void gitFetch(String remote) throws ExceptionDBGit { fetch.call(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "done")); + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "done"), messageLevel); } catch (Exception e) { throw new ExceptionDBGit(e); } } private CredentialsProvider getCredentialsProviderByName(String remoteName) throws ExceptionDBGit { - ConsoleWriter.detailsPrintLn("Getting link to repo... "); + ConsoleWriter.detailsPrintln(DBGitLang.getInstance() + .getValue("general", "gettingRepoLink") + , messageLevel + ); String link = git.getRepository().getConfig().getString("remote", remoteName, "url"); - ConsoleWriter.detailsPrintLn("link:" + link); + ConsoleWriter.detailsPrintln(DBGitLang.getInstance() + .getValue("general", "repoLink") + .withParams(link) + , messageLevel + ); if (link != null) return getCredentialsProvider(link); @@ -504,12 +555,19 @@ private CredentialsProvider getCredentialsProvider() throws ExceptionDBGit { private static CredentialsProvider getCredentialsProvider(String link) throws ExceptionDBGit { try { - ConsoleWriter.detailsPrintLn("Getting credentials..."); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "parsingDbCredentials") + , 0 + ); URIish uri = new URIish(link); - ConsoleWriter.detailsPrintLn("uri login = " + uri.getUser()); - ConsoleWriter.detailsPrintLn("uri pass = " + uri.getPass()); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "showDbCredentials") + .withParams( uri.getScheme(), uri.getUser(), uri.getHost(), uri.getRawPath()) + , 0 + ); + /* Pattern patternPass = Pattern.compile("(?<=:(?!\\/))(.*?)(?=@)"); Pattern patternLogin = Pattern.compile("(?<=\\/\\/)(.*?)(?=:(?!\\/))"); @@ -536,7 +594,7 @@ private static CredentialsProvider getCredentialsProvider(String link) throws Ex ConsoleWriter.detailsPrintLn("login: " + login); ConsoleWriter.detailsPrintLn("pass: " + pass);*/ if(uri.getUser() == null) { - ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance().getValue("errors", "gitLoginNotFound")); + ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance().getValue("errors", "gitLoginNotFound"), messageLevel); return null; } return new UsernamePasswordCredentialsProvider(uri.getUser(), uri.getPass()); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java index 3c5c956..b09edfb 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java @@ -1,155 +1,158 @@ -package ru.fusionsoft.dbgit.core; - -import java.io.File; - -import org.ini4j.Ini; - -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -public class DBGitConfig { - - private static DBGitConfig config = null; - private Ini ini = null; - private Ini iniGlobal = null; - - private DBGitConfig() throws Exception { - - if (DBGit.checkIfRepositoryExists()) { - File file = new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG); - if (file.exists()) - ini = new Ini(file); - } - - String path = new File(DBGitConfig.class.getProtectionDomain().getCodeSource().getLocation() - .toURI()).getAbsolutePath(); - - //for debug: - if (path.contains("classes")) path = path + "/../dbgit"; - - while (!new File(path + "/dbgitconfig").exists()) { - int i = path.lastIndexOf("/"); - if (i == -1) i = path.lastIndexOf("\\"); - - path = path.substring(0, i); - } - - if (new File(path + "/bin/dbgitconfig").exists()) - path = path + "/bin/dbgitconfig"; - else - path = path + "/dbgitconfig"; - - File fileGlobal = new File(path); - if (fileGlobal.exists()) - iniGlobal = new Ini(fileGlobal); - } - - public static DBGitConfig getInstance() throws Exception { - if (config == null) - config = new DBGitConfig(); - - return config; - } - - public String getString(String section, String option, String defaultValue) { - return getString(section, option, defaultValue, false); - } - - public Boolean getBoolean(String section, String option, Boolean defaultValue) { - return getBoolean(section, option, defaultValue, false); - } - - public Integer getInteger(String section, String option, Integer defaultValue) { - return getInteger(section, option, defaultValue, false); - } - - public Double getDouble(String section, String option, Double defaultValue) { - return getDouble(section, option, defaultValue, false); - } - - public String getStringGlobal(String section, String option, String defaultValue) { - return getString(section, option, defaultValue, true); - } - - public Boolean getBooleanGlobal(String section, String option, Boolean defaultValue) { - return getBoolean(section, option, defaultValue, true); - } - - public Integer getIntegerGlobal(String section, String option, Integer defaultValue) { - return getInteger(section, option, defaultValue, true); - } - - public Double getDoubleGlobal(String section, String option, Double defaultValue) { - return getDouble(section, option, defaultValue, true); - } - - private String getString(String section, String option, String defaultValue, boolean global) { - try { - String result = global ? iniGlobal.get(section, option) : ini.get(section, option); - return result == null ? defaultValue : result; - } catch (Exception e) { - return defaultValue; - } - } - - private Boolean getBoolean(String section, String option, Boolean defaultValue, boolean global) { - try { - String result = global ? iniGlobal.get(section, option) : ini.get(section, option); - - return result == null ? defaultValue : Boolean.valueOf(result); - } catch (Exception e) { - return defaultValue; - } - } - - private Integer getInteger(String section, String option, Integer defaultValue, boolean global) { - try { - String result = global ? iniGlobal.get(section, option) : ini.get(section, option); - return result == null ? defaultValue : Integer.valueOf(result); - } catch (Exception e) { - return defaultValue; - } - } - - private Double getDouble(String section, String option, Double defaultValue, boolean global) { - try { - String result = global ? iniGlobal.get(section, option) : ini.get(section, option); - return result == null ? defaultValue : Double.valueOf(result); - } catch (Exception e) { - return defaultValue; - } - } - - public void setValue(String parameter, String value) throws ExceptionDBGit { - setValue(parameter, value, false); - } - - public void setValueGlobal(String parameter, String value) throws ExceptionDBGit { - setValue(parameter, value, true); - } - - public void setValue(String parameter, String value, boolean global) throws ExceptionDBGit { - try { - if (global) { - if (!iniGlobal.get("core").containsKey(parameter)) - ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("errors", "config", "noParameter").withParams(parameter)); - else { - iniGlobal.get("core").put(parameter, value); - iniGlobal.store(iniGlobal.getFile()); - } - } else { - if (ini == null) - throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "gitRepNotFound")); - - if (!ini.get("core").containsKey(parameter)) - ConsoleWriter.detailsPrintLn(DBGitLang.getInstance().getValue("errors", "config", "noParameter").withParams(parameter)); - else { - ini.get("core").put(parameter, value); - ini.store(new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG)); - } - } - } catch (Exception e) { - throw new ExceptionDBGit(e); - } - } - -} +package ru.fusionsoft.dbgit.core; + +import java.io.File; + +import org.ini4j.Ini; + +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +public class DBGitConfig { + private static int messageLevel = 1; + private static DBGitConfig config = null; + private Ini ini = null; + private Ini iniGlobal = null; + + private DBGitConfig() throws Exception { + + if (DBGit.checkIfRepositoryExists()) { + File file = new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG); + if (file.exists()) + ini = new Ini(file); + } + + String path = new File(DBGitConfig.class.getProtectionDomain().getCodeSource().getLocation() + .toURI()).getAbsolutePath(); + + //for debug: + if (path.contains("classes")) path = path + "/../dbgit"; + + while (!new File(path + "/dbgitconfig").exists()) { + int i = path.lastIndexOf("/"); + if (i == -1) i = path.lastIndexOf("\\"); + + path = path.substring(0, i); + } + + if (new File(path + "/bin/dbgitconfig").exists()) + path = path + "/bin/dbgitconfig"; + else + path = path + "/dbgitconfig"; + + File fileGlobal = new File(path); + if (fileGlobal.exists()) + iniGlobal = new Ini(fileGlobal); + } + + public static DBGitConfig getInstance() throws Exception { + if (config == null) + config = new DBGitConfig(); + + return config; + } + + public String getString(String section, String option, String defaultValue) { + return getString(section, option, defaultValue, false); + } + + public Boolean getBoolean(String section, String option, Boolean defaultValue) { + return getBoolean(section, option, defaultValue, false); + } + + public Integer getInteger(String section, String option, Integer defaultValue) { + return getInteger(section, option, defaultValue, false); + } + + public Double getDouble(String section, String option, Double defaultValue) { + return getDouble(section, option, defaultValue, false); + } + + public String getStringGlobal(String section, String option, String defaultValue) { + return getString(section, option, defaultValue, true); + } + + public Boolean getBooleanGlobal(String section, String option, Boolean defaultValue) { + return getBoolean(section, option, defaultValue, true); + } + + public Integer getIntegerGlobal(String section, String option, Integer defaultValue) { + return getInteger(section, option, defaultValue, true); + } + + public Double getDoubleGlobal(String section, String option, Double defaultValue) { + return getDouble(section, option, defaultValue, true); + } + + private String getString(String section, String option, String defaultValue, boolean global) { + try { + String result = global ? iniGlobal.get(section, option) : ini.get(section, option); + return result == null ? defaultValue : result; + } catch (Exception e) { + return defaultValue; + } + } + + private Boolean getBoolean(String section, String option, Boolean defaultValue, boolean global) { + try { + String result = global ? iniGlobal.get(section, option) : ini.get(section, option); + + return result == null ? defaultValue : Boolean.valueOf(result); + } catch (Exception e) { + return defaultValue; + } + } + + private Integer getInteger(String section, String option, Integer defaultValue, boolean global) { + try { + String result = global ? iniGlobal.get(section, option) : ini.get(section, option); + return result == null ? defaultValue : Integer.valueOf(result); + } catch (Exception e) { + return defaultValue; + } + } + + private Double getDouble(String section, String option, Double defaultValue, boolean global) { + try { + String result = global ? iniGlobal.get(section, option) : ini.get(section, option); + return result == null ? defaultValue : Double.valueOf(result); + } catch (Exception e) { + return defaultValue; + } + } + + public void setValue(String parameter, String value) throws ExceptionDBGit { + setValue(parameter, value, false); + } + + public void setValueGlobal(String parameter, String value) throws ExceptionDBGit { + setValue(parameter, value, true); + } + + public void setValue(String parameter, String value, boolean global) throws ExceptionDBGit { + try { + if (global) { + if (!iniGlobal.get("core").containsKey(parameter)) + ConsoleWriter.detailsPrintln( + DBGitLang.getInstance().getValue("errors", "config", "noParameter").withParams(parameter) + , messageLevel + ); + else { + iniGlobal.get("core").put(parameter, value); + iniGlobal.store(iniGlobal.getFile()); + } + } else { + if (ini == null) + throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "gitRepNotFound")); + + if (!ini.get("core").containsKey(parameter)) + ConsoleWriter.detailsPrintln(DBGitLang.getInstance().getValue("errors", "config", "noParameter").withParams(parameter), messageLevel); + else { + ini.get("core").put(parameter, value); + ini.store(new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG)); + } + } + } catch (Exception e) { + throw new ExceptionDBGit(e); + } + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitLang.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitLang.java index a899a65..82a6451 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitLang.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitLang.java @@ -33,7 +33,6 @@ private DBGitLang() { new Yaml().load(new FileInputStream(new File(path + "/lang/" + DBGitConfig.getInstance().getString("core", "LANG", DBGitConfig.getInstance().getStringGlobal("core", "LANG", "no")).toLowerCase() + ".yaml"))); } catch (Exception e) { - ConsoleWriter.println(e.getLocalizedMessage()); throw new ExceptionDBGitRunTime(e); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java index eea468c..efa1fa0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java @@ -6,6 +6,7 @@ import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; +import java.sql.Connection; import java.sql.SQLException; /** @@ -17,52 +18,70 @@ public class ExceptionDBGit extends Exception { private static final long serialVersionUID = -4613368557825624023L; - private Logger logger = LoggerUtil.getLogger(this.getClass()); + protected Logger logger = LoggerUtil.getLogger(this.getClass()); + protected static int messageLevel = 0; + private Throwable cause = null; + private String contextMessage = null; public ExceptionDBGit(Object msg) { - this(msg.toString()); + this.setContextMessage(msg.toString()); + handleException(); } - - public ExceptionDBGit(String msg) { - super(msg); - rollbackConnection(); - ConsoleWriter.printlnRed(msg); - ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(this)); - logger.error(msg); - System.exit(1); + public ExceptionDBGit(Object message, Throwable cause) { + this.setContextMessage(message.toString()); + this.setCause(cause); + handleException(); + } + public ExceptionDBGit(Throwable cause) { + this.setCause(cause); + handleException(); } - - public ExceptionDBGit(String message, Throwable cause) { + private void handleException(){ + printMessageAndStackTrace(); rollbackConnection(); + System.exit(1); + } - if(message != null && !message.equals(cause.getMessage())) { - ConsoleWriter.printlnRed(message); + public void printMessageAndStackTrace(){ + if(contextMessage != null && (cause == null || !cause.getMessage().equals(contextMessage))) { + ConsoleWriter.printlnRed(contextMessage, messageLevel); + ConsoleWriter.printLineBreak(); } - ConsoleWriter.printlnRed(cause.getLocalizedMessage()); - ConsoleWriter.detailsPrintlnRed(ExceptionUtils.getStackTrace(cause)); - ConsoleWriter.printlnRed(""); + if(cause != null){ + ConsoleWriter.printlnRed(cause.getLocalizedMessage(), messageLevel); + ConsoleWriter.printLineBreak(); + ConsoleWriter.detailsPrintlnRed(ExceptionUtils.getStackTrace(cause), messageLevel); + logger.error(contextMessage != null ? contextMessage : cause.getMessage(), cause); - logger.error(message != null ? message : cause.getMessage(), cause); - System.exit(1); + } else { + ConsoleWriter.detailsPrintlnRed(ExceptionUtils.getStackTrace(this), messageLevel); + logger.error(contextMessage != null ? contextMessage : "no error message provided..." , this); + } } - private void rollbackConnection() { - try{ - DBConnection conn = DBConnection.getInstance(); - conn.getConnect().rollback(); + if(DBConnection.hasInstance()) try{ + DBConnection dbConnection = DBConnection.getInstance(); + Connection connection = dbConnection.getConnect(); + if(connection != null && !connection.isClosed()){ + connection.rollback(); + connection.close(); + } } catch (Exception ex) { if(ex instanceof ExceptionDBGit || ex instanceof SQLException) { - ConsoleWriter.detailsPrintlnRed("Failed to rollback connection: " + ex.getLocalizedMessage()); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "onExceptionTransactionRollbackError") + .withParams(ex.getLocalizedMessage()) + , 0 + ); } else { - ConsoleWriter.printlnRed(ex.getLocalizedMessage()); + ConsoleWriter.printlnRed(ex.getLocalizedMessage(), messageLevel); } } } - public ExceptionDBGit(Throwable cause) { - this(null, cause); - } + public void setCause(Throwable cause) { this.cause = cause; } + public void setContextMessage(String contextMessage) { this.contextMessage = contextMessage; } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java index be8e8f0..439d04c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java @@ -6,15 +6,18 @@ public class ExceptionDBGitRestore extends ExceptionDBGit { private static final long serialVersionUID = -8714585942496838509L; - public ExceptionDBGitRestore(String msg) { - super(msg); - } - - public ExceptionDBGitRestore(String message, Throwable cause) { - super(message, cause); + public ExceptionDBGitRestore(Object msg) { super(msg); } + public ExceptionDBGitRestore(Object message, Throwable cause) { super(message, cause); } + public ExceptionDBGitRestore(Throwable cause) { super(cause); } + + @Override public void printMessageAndStackTrace(){ + printFail(); + super.printMessageAndStackTrace(); } - - public ExceptionDBGitRestore(Throwable cause) { - super(cause); + + private void printFail(){ + ConsoleWriter.detailsPrintRed(DBGitLang.getInstance() + .getValue("errors", "meta", "fail") + ); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java index 87a27d7..e80bfaf 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java @@ -10,40 +10,20 @@ public class ExceptionDBGitRunTime extends RuntimeException { private static final long serialVersionUID = 958722213419205629L; - private Logger logger = LoggerUtil.getLogger(this.getClass()); - - public ExceptionDBGitRunTime(String msg) { - super(msg); - } - - public ExceptionDBGitRunTime(String message, Throwable cause) { - try{ - DBConnection conn = DBConnection.getInstance(); - conn.getConnect().rollback(); - //super(message, cause); - } catch (Exception ex) { - if(ex instanceof ExceptionDBGit || ex instanceof SQLException) { - ConsoleWriter.detailsPrintlnRed("Failed to rollback connection: " + ex.getLocalizedMessage()); - } else { - ConsoleWriter.printlnRed(ex.getLocalizedMessage()); - } - } - ConsoleWriter.printlnRed(message ); - - if(cause instanceof SQLException){ - ConsoleWriter.printlnRed(ExceptionUtils.getStackTrace(cause)); + private ExceptionDBGit exceptionDBGit; - } else if ( !message.equals(cause.getMessage()) ){ - ConsoleWriter.printlnRed(cause.getMessage() ); - ConsoleWriter.detailsPrintLn(ExceptionUtils.getStackTrace(cause)); - } - logger.error(message, cause); - System.exit(1); + public ExceptionDBGitRunTime(Object msg) { + super(msg.toString()); + exceptionDBGit = new ExceptionDBGit(this); + } + public ExceptionDBGitRunTime(Object message, Throwable cause) { + super(message.toString(), cause); + exceptionDBGit = new ExceptionDBGit(this); } - + public ExceptionDBGitRunTime(Throwable cause) { - this(cause.getLocalizedMessage(), cause); + super(cause); + exceptionDBGit = new ExceptionDBGit(this); } - } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java index 9d9f72f..3aa062c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java @@ -44,7 +44,8 @@ public class GitMetaDataManager { private MetaTableData currentPortion = null; private int currentPortionIndex = 0; - + private static int messageLevel = 1; + protected GitMetaDataManager() { dbObjs = new TreeMapMetaObject(); fileObjs = new TreeMapMetaObject(); @@ -126,14 +127,14 @@ public boolean loadNextPortion(MetaTable tbl) throws ExceptionDBGit { if (currentPortion == null || !tbl.getName().replace(".tbl", ".csv") .equalsIgnoreCase(currentPortion.getName())) currentPortionIndex = 0; - ConsoleWriter.detailsPrint(DBGitLang.getInstance().getValue("general", "add", "loading") + " " + currentPortionIndex + ", ", 2); + ConsoleWriter.detailsPrintln(DBGitLang.getInstance().getValue("general", "add", "loading") + " " + currentPortionIndex + ", ", messageLevel); currentPortion = new MetaTableData(tbl.getTable()); if (currentPortion.getmapRows() != null) currentPortion.getmapRows().clear(); if (!currentPortion.loadPortionFromDB(currentPortionIndex)) return false; - ConsoleWriter.detailsPrint(DBGitLang.getInstance().getValue("general", "add", "size") + " " + currentPortion.getmapRows().size() + "\n", 2); + ConsoleWriter.detailsPrintln(DBGitLang.getInstance().getValue("general", "add", "size") + " " + currentPortion.getmapRows().size() , messageLevel); currentPortionIndex++; try { @@ -181,9 +182,9 @@ public IMapMetaObject loadDBMetaData(boolean includeBackupSchemas) throws Except schemes = new HashMap(); try { schemes.put(adapter.getConnection().getSchema(), new DBSchema(adapter.getConnection().getSchema())); - ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "meta", "cantGetOtherUsersObjects")); + ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "meta", "cantGetOtherUsersObjects"), messageLevel); } catch (SQLException e) { - throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "meta", "cantGetCurrentSchema")); + throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "meta", "cantGetCurrentSchema").toString(), e); } } @@ -287,12 +288,22 @@ public IMapMetaObject loadFileMetaData(boolean force) throws ExceptionDBGit { List files = dbGit.getGitIndexFiles(DBGitPath.DB_GIT_PATH); boolean isSuccessful = true; - ConsoleWriter.detailsPrintLn("Loading files...", 1); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "meta", "loadFiles") + .withParams("") + , messageLevel + ); + for (int i = 0; i < files.size(); i++) { String filename = files.get(i); if (DBGitPath.isServiceFile(filename)) continue; - ConsoleWriter.detailsPrintLn("Loading file " + filename + "...", 2); - + + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "meta", "loadFile") + .withParams(filename) + , messageLevel+1 + ); + if (force) { IMetaObject obj = loadMetaFile(filename); @@ -309,9 +320,11 @@ public IMapMetaObject loadFileMetaData(boolean force) throws ExceptionDBGit { } } catch (Exception e) { isSuccessful = false; - ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance().getValue("errors", "meta", "fail")); - e.printStackTrace(); - ConsoleWriter.detailsPrintLn(e.getMessage()); + ConsoleWriter.printlnRed(DBGitLang.getInstance().getValue("errors", "meta", "loadMetaFile") + .withParams(filename) + , messageLevel + ); + ConsoleWriter.detailsPrintln(e.getMessage(), messageLevel); IMetaObject obj = MetaObjectFactory.createMetaObject(filename); objs.put(obj); diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java index 25cc2cd..d127076 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/MapFileData.java @@ -21,6 +21,8 @@ public class MapFileData implements ICellData { private String srcFile = null; private File tmpFile = null; private static Set filesNotFound = new HashSet<>(); + private static int messageLevel = 2; + //private String hash = null; public InputStream getBlobData(ResultSet rs, String fieldname) throws Exception { @@ -47,7 +49,10 @@ public String serialize(DBTable tbl) throws Exception { DBGitPath.createDir(wrtFile.getAbsolutePath()); Files.move(tmpFile.toPath(), wrtFile.toPath(), StandardCopyOption.REPLACE_EXISTING); - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "dataTable", "writeData").withParams(srcFile)); + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "dataTable", "writeData") + .withParams(srcFile) + , messageLevel + ); tmpFile = null; } return srcFile; diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java index 3085da3..57b6808 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java @@ -34,7 +34,9 @@ */ public interface IMetaObject { public static final String EMPTY_HASH = ""; - public static final int MAX_FILE_NAME_LENGTH = 130; + public static final int MAX_FILE_NAME_LENGTH = 130; + public static int messageLevel = 1; + /** * * @return Type meta object diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index 116b7ac..08b887d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -1,452 +1,460 @@ -package ru.fusionsoft.dbgit.meta; - -import java.io.*; -import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; -import java.sql.ResultSet; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.TreeMap; -import java.util.concurrent.TimeUnit; - -import de.siegmar.fastcsv.reader.CsvParser; -import de.siegmar.fastcsv.reader.CsvReader; -import de.siegmar.fastcsv.reader.CsvRow; -import org.apache.commons.codec.binary.Base64; - -import org.apache.commons.csv.CSVFormat; -import org.apache.commons.csv.CSVParser; -import org.apache.commons.csv.CSVPrinter; -import org.apache.commons.csv.CSVRecord; - -import org.apache.commons.csv.QuoteMode; - -import com.diogonunes.jcdp.color.api.Ansi.FColor; - -import ru.fusionsoft.dbgit.adapters.AdapterFactory; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.DBGit; -import ru.fusionsoft.dbgit.core.DBGitConfig; -import ru.fusionsoft.dbgit.core.DBGitLang; -import ru.fusionsoft.dbgit.core.DBGitPath; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; -import ru.fusionsoft.dbgit.core.GitMetaDataManager; -import ru.fusionsoft.dbgit.data_table.ICellData; -import ru.fusionsoft.dbgit.data_table.MapFileData; -import ru.fusionsoft.dbgit.data_table.RowData; -import ru.fusionsoft.dbgit.data_table.TreeMapRowData; -import ru.fusionsoft.dbgit.dbobjects.DBTable; -import ru.fusionsoft.dbgit.dbobjects.DBTableData; -import ru.fusionsoft.dbgit.utils.CalcHash; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -/** - * Meta class for Table data - * @author mikle - * - */ -public class MetaTableData extends MetaBase { - protected DBTable table = null; - private DBTableData dataTable = null; - - private TreeMapRowData mapRows = null; - private List fields = new ArrayList<>(); - - public MetaTableData() { - setDbType(); - setDbVersion(); - } - - public MetaTableData(DBTable tbl) throws ExceptionDBGit { - setDbType(); - setDbVersion(); - setTable(tbl); - } - - - public DBTable getTable() { - return table; - } - - public TreeMap getmapRows() { - return mapRows; - } - - public DBTableData getDataTable() { - return dataTable; - } - - public void setMapRows(TreeMapRowData mapRows) { - this.mapRows = mapRows; - } - - public void setDataTable(DBTableData dataTable) { - this.dataTable = dataTable; - } - - public void setTable(DBTable table) throws ExceptionDBGit { - this.table = table; - setName(table.getSchema()+"/"+table.getName()+"."+getType().getValue()); - } - - - - @Override - public void setName(String name) throws ExceptionDBGit { - if (table == null) { - NameMeta nm = MetaObjectFactory.parseMetaName(name); - table = new DBTable(); - table.setSchema(nm.getSchema()); - table.setName(nm.getName()); - } - - super.setName(name); - } - - @Override - public DBGitMetaType getType() { - return DBGitMetaType.DbGitTableData; - } - - public CSVFormat getCSVFormat() { - return CSVFormat.DEFAULT - //.withRecordSeparator("\n") - .withDelimiter(';') - .withNullString("") - .withQuote('"') - //.withQuoteMode(QuoteMode.ALL) - ; - } - - public MetaTable getMetaTable() throws ExceptionDBGit { - String metaTblName = table.getSchema()+"/"+table.getName()+"."+DBGitMetaType.DBGitTable.getValue(); - GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); - - IMapMetaObject dbObjs = gmdm.getCacheDBMetaData(); - MetaTable metaTable = (MetaTable) dbObjs.get(metaTblName); - if (metaTable == null ) { - metaTable = new MetaTable(); - metaTable.loadFromDB(table); - } - return metaTable; - } - - public MetaTable getMetaTableFromFile() throws ExceptionDBGit { - String metaTblName = table.getSchema()+"/"+table.getName()+"."+DBGitMetaType.DBGitTable.getValue(); - GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); - - MetaTable metaTable = (MetaTable)gmdm.loadMetaFile(metaTblName); - if (metaTable != null) - return metaTable; - - //TODO ... which is not from file, but from db - return getMetaTable(); - } - - - @Override - public boolean serialize(OutputStream stream) throws Exception { - Integer count = 0; - Set fields = null; - - if (mapRows == null) { - return false; - } - - CSVPrinter csvPrinter = new CSVPrinter(new OutputStreamWriter(stream), getCSVFormat()); - - for (RowData rd : mapRows.values()) { - if (count == 0) { - fields = rd.getData(this.fields).keySet(); - csvPrinter.printRecord(fields); - } - - rd.saveDataToCsv(csvPrinter, getTable()); - - count++; - } - csvPrinter.close(); - return true; - } - - @Override - public IMetaObject deSerialize(File file) throws Exception { - MetaTable metaTable = getMetaTableFromFile(); - - CsvReader csvReader = new CsvReader(); - csvReader.setFieldSeparator(';'); - int i = 1; - - try (CsvParser csvParser = csvReader.parse(file, StandardCharsets.UTF_8)) { - CsvRow row; - boolean flag = false; - mapRows = new TreeMapRowData(); - CsvRow titleColumns = null; - - - while ((row = csvParser.nextRow()) != null) { - if (!flag) { - titleColumns = row; - fields = row.getFields(); - } else { - RowData rd = new RowData(row, metaTable, titleColumns); - mapRows.put(rd); - i++; - } - flag = true; - } - } catch (Throwable ex){ - ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance().getValue("general", "meta", "loadRow").withParams(String.valueOf(i) )); - warnFilesNotFound(); - throw ex; - } - ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "meta", "loadedRow").withParams(String.valueOf(i) )); - warnFilesNotFound(); - - return this; - } - - - @Override - public IMetaObject deSerialize(InputStream stream) throws Exception { - - MetaTable metaTable = getMetaTableFromFile(); - - CSVParser csvParser = new CSVParser(new InputStreamReader(stream), getCSVFormat()); - List csvRecords = csvParser.getRecords(); - - if (csvRecords.size() > 0) { - CSVRecord titleColumns = csvRecords.get(0); - fields.clear(); - for (int i = 0; i < csvRecords.get(0).size(); i++) { - fields.add(csvRecords.get(0).get(i)); - } - - mapRows = new TreeMapRowData(); - - for (int i = 1; i < csvRecords.size(); i++) { - RowData rd = new RowData(csvRecords.get(i), metaTable, titleColumns); - mapRows.put(rd); - } - } - - - csvParser.close(); - - //saveToFile("test"); - - return this; - } - - public boolean loadPortionFromDB(int currentPortionIndex) throws ExceptionDBGit { - return loadPortionFromDB(currentPortionIndex, 0); - } - - public boolean loadPortionFromDB(int currentPortionIndex, int tryNumber) throws ExceptionDBGit { - try { - IDBAdapter adapter = AdapterFactory.createAdapter(); - MetaTable metaTable = getMetaTable(); - if (metaTable.getFields().size() == 0) - return false; - - dataTable = adapter.getTableDataPortion(table.getSchema(), table.getName(), currentPortionIndex, 0); - - ResultSet rs = dataTable.getResultSet(); - - if (dataTable.getErrorFlag() > 0) { - ConsoleWriter.printlnColor(DBGitLang.getInstance().getValue("errors", "meta", "tooManyRecords"). - withParams(getName(), String.valueOf(IDBAdapter.MAX_ROW_COUNT_FETCH)), FColor.RED, 0); - return false; - } - - mapRows = new TreeMapRowData(); - - boolean flag = false; - while(rs.next()){ - - if (!flag) { - fields.clear(); - for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) { - String columnName = rs.getMetaData().getColumnName(i + 1); - if (columnName.equalsIgnoreCase("DBGIT_ROW_NUM")) - continue; - fields.add(columnName); - } - } - - flag = true; - RowData rd = new RowData(rs, metaTable); - mapRows.put(rd); - } - - - - return true; - } catch (Exception e) { - e.printStackTrace(); - ConsoleWriter.println(e.getMessage()); - ConsoleWriter.println(e.getLocalizedMessage()); - - try { - if (tryNumber <= DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000))) { - try { - TimeUnit.SECONDS.sleep(DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000))); - } catch (InterruptedException e1) { - throw new ExceptionDBGitRunTime(e1.getMessage()); - } - ConsoleWriter.println("Error while getting portion of data, try " + tryNumber); - return loadPortionFromDB(currentPortionIndex, tryNumber++); - } - } catch (Exception e1) { - // TODO Auto-generated catch block - e1.printStackTrace(); - } - - if (e instanceof ExceptionDBGit) - throw (ExceptionDBGit)e; - throw new ExceptionDBGit(e); - } - } - - @Override - public boolean loadFromDB() throws ExceptionDBGit { - try { - IDBAdapter adapter = AdapterFactory.createAdapter(); - - MetaTable metaTable = getMetaTable(); - - if (metaTable.getFields().size() == 0) - return false; - - dataTable = adapter.getTableData(table.getSchema(), table.getName()); - - if (dataTable.getErrorFlag() > 0) { - ConsoleWriter.printlnColor(DBGitLang.getInstance().getValue("errors", "meta", "tooManyRecords"). - withParams(getName(), String.valueOf(IDBAdapter.MAX_ROW_COUNT_FETCH)), FColor.RED, 0); - return false; - } - - ResultSet rs = dataTable.getResultSet(); - - mapRows = new TreeMapRowData(); - - //System.out.println("load from db file "+getName()); - while(rs.next()){ - RowData rd = new RowData(rs, metaTable); - mapRows.put(rd); - } - return true; - /* - System.out.println("******************************************"); - System.out.println(); - */ - } catch (Exception e) { - e.printStackTrace(); - if (e instanceof ExceptionDBGit) - throw (ExceptionDBGit)e; - throw new ExceptionDBGit(e); - } - - } - - public void diff(MetaTableData ob) throws Exception { - if (mapRows.size() != ob.mapRows.size()) { - System.out.println(DBGitLang.getInstance().getValue("general", "meta", "diffSize1").withParams(String.valueOf(mapRows.size()), String.valueOf(ob.mapRows.size()))); - } - for (String rowHash : mapRows.keySet()) { - RowData r1 = mapRows.get(rowHash); - RowData r2 = ob.mapRows.get(rowHash); - - System.out.println(rowHash); - System.out.println(r1.getData(fields)+ " "+ r2.getData(ob.fields)); - - if (r1.getData(fields).size() != r2.getData(ob.fields).size()) { - System.out.println(DBGitLang.getInstance().getValue("general", "meta", "diffSize2").withParams(rowHash)); - } - - for (String col : r1.getData(fields).keySet()) { - String d1 = r1.getData(fields).get(col).convertToString(); - String d2 = r2.getData(ob.fields).get(col).convertToString(); - - if (d1 != d2) { - if (!d1.equals(r2.getData(ob.fields).get(col))) { - System.out.println(DBGitLang.getInstance().getValue("general", "meta", "diffDataRow"). - withParams(rowHash, col, r1.getData(fields).get(col).toString(), r2.getData(ob.fields).get(col).toString())); - } - } - } - } - } - - - @Override - public String getHash() { - CalcHash ch = new CalcHash(); - if (mapRows == null) - return EMPTY_HASH; - - if (mapRows.size() == 0) - return EMPTY_HASH; - - //System.out.println(getName()); - int n = 0; - for (RowData rd : mapRows.values()) { - ch.addData(rd.getHashRow()); - //System.out.println("row "+n+" "+rd.getHashRow()); - n++; - } - - return ch.calcHashStr(); - } - - @Override - public int addToGit() throws ExceptionDBGit { - int count = super.addToGit(); - - if (mapRows == null) return count; - - for (RowData rd : mapRows.values()) { - for (ICellData cd : rd.getData(fields).values()) { - count += cd.addToGit(); - } - } - - return count; - } - - @Override - public int removeFromGit() throws ExceptionDBGit { - int count = super.removeFromGit(); - - if (mapRows == null) - return 1; - - for (RowData rd : mapRows.values()) { - for (ICellData cd : rd.getData(fields).values()) { - count += cd.removeFromGit(); - } - } - - return count; - } - - public List getFields() { - return fields; - } - - private void warnFilesNotFound(){ - Set filesNotFound = MapFileData.getFilesNotFound(); - if(filesNotFound != null && filesNotFound.size() > 0){ - ConsoleWriter.detailsPrintColor( - DBGitLang.getInstance().getValue("errors", "dataTable", "filesNotFound") - .withParams(String.join(";", filesNotFound)), 0, FColor.YELLOW - ); - filesNotFound.clear(); - } - - } -} +package ru.fusionsoft.dbgit.meta; + +import java.io.*; +import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import java.sql.ResultSet; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeMap; +import java.util.concurrent.TimeUnit; + +import de.siegmar.fastcsv.reader.CsvParser; +import de.siegmar.fastcsv.reader.CsvReader; +import de.siegmar.fastcsv.reader.CsvRow; +import org.apache.commons.codec.binary.Base64; + +import org.apache.commons.csv.CSVFormat; +import org.apache.commons.csv.CSVParser; +import org.apache.commons.csv.CSVPrinter; +import org.apache.commons.csv.CSVRecord; + +import org.apache.commons.csv.QuoteMode; + +import com.diogonunes.jcdp.color.api.Ansi.FColor; + +import org.apache.commons.lang3.exception.ExceptionUtils; +import org.slf4j.Logger; +import ru.fusionsoft.dbgit.adapters.AdapterFactory; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGit; +import ru.fusionsoft.dbgit.core.DBGitConfig; +import ru.fusionsoft.dbgit.core.DBGitLang; +import ru.fusionsoft.dbgit.core.DBGitPath; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; +import ru.fusionsoft.dbgit.core.GitMetaDataManager; +import ru.fusionsoft.dbgit.data_table.ICellData; +import ru.fusionsoft.dbgit.data_table.MapFileData; +import ru.fusionsoft.dbgit.data_table.RowData; +import ru.fusionsoft.dbgit.data_table.TreeMapRowData; +import ru.fusionsoft.dbgit.dbobjects.DBTable; +import ru.fusionsoft.dbgit.dbobjects.DBTableData; +import ru.fusionsoft.dbgit.utils.CalcHash; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.utils.LoggerUtil; + +/** + * Meta class for Table data + * @author mikle + * + */ +public class MetaTableData extends MetaBase { + private Logger logger = LoggerUtil.getLogger(this.getClass()); + protected DBTable table = null; + private DBTableData dataTable = null; + + private TreeMapRowData mapRows = null; + private List fields = new ArrayList<>(); + + public MetaTableData() { + setDbType(); + setDbVersion(); + } + + public MetaTableData(DBTable tbl) throws ExceptionDBGit { + setDbType(); + setDbVersion(); + setTable(tbl); + } + + + public DBTable getTable() { + return table; + } + + public TreeMap getmapRows() { + return mapRows; + } + + public DBTableData getDataTable() { + return dataTable; + } + + public void setMapRows(TreeMapRowData mapRows) { + this.mapRows = mapRows; + } + + public void setDataTable(DBTableData dataTable) { + this.dataTable = dataTable; + } + + public void setTable(DBTable table) throws ExceptionDBGit { + this.table = table; + setName(table.getSchema()+"/"+table.getName()+"."+getType().getValue()); + } + + + + @Override + public void setName(String name) throws ExceptionDBGit { + if (table == null) { + NameMeta nm = MetaObjectFactory.parseMetaName(name); + table = new DBTable(); + table.setSchema(nm.getSchema()); + table.setName(nm.getName()); + } + + super.setName(name); + } + + @Override + public DBGitMetaType getType() { + return DBGitMetaType.DbGitTableData; + } + + public CSVFormat getCSVFormat() { + return CSVFormat.DEFAULT + //.withRecordSeparator("\n") + .withDelimiter(';') + .withNullString("") + .withQuote('"') + //.withQuoteMode(QuoteMode.ALL) + ; + } + + public MetaTable getMetaTable() throws ExceptionDBGit { + String metaTblName = table.getSchema()+"/"+table.getName()+"."+DBGitMetaType.DBGitTable.getValue(); + GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); + + IMapMetaObject dbObjs = gmdm.getCacheDBMetaData(); + MetaTable metaTable = (MetaTable) dbObjs.get(metaTblName); + if (metaTable == null ) { + metaTable = new MetaTable(); + metaTable.loadFromDB(table); + } + return metaTable; + } + + public MetaTable getMetaTableFromFile() throws ExceptionDBGit { + String metaTblName = table.getSchema()+"/"+table.getName()+"."+DBGitMetaType.DBGitTable.getValue(); + GitMetaDataManager gmdm = GitMetaDataManager.getInstance(); + + MetaTable metaTable = (MetaTable)gmdm.loadMetaFile(metaTblName); + if (metaTable != null) + return metaTable; + + //TODO ... which is not from file, but from db + return getMetaTable(); + } + + + @Override + public boolean serialize(OutputStream stream) throws Exception { + Integer count = 0; + Set fields = null; + + if (mapRows == null) { + return false; + } + + CSVPrinter csvPrinter = new CSVPrinter(new OutputStreamWriter(stream), getCSVFormat()); + + for (RowData rd : mapRows.values()) { + if (count == 0) { + fields = rd.getData(this.fields).keySet(); + csvPrinter.printRecord(fields); + } + + rd.saveDataToCsv(csvPrinter, getTable()); + + count++; + } + csvPrinter.close(); + return true; + } + + @Override + public IMetaObject deSerialize(File file) throws Exception { + MetaTable metaTable = getMetaTableFromFile(); + + CsvReader csvReader = new CsvReader(); + csvReader.setFieldSeparator(';'); + int i = 1; + + try (CsvParser csvParser = csvReader.parse(file, StandardCharsets.UTF_8)) { + CsvRow row; + boolean flag = false; + mapRows = new TreeMapRowData(); + CsvRow titleColumns = null; + + + while ((row = csvParser.nextRow()) != null) { + if (!flag) { + titleColumns = row; + fields = row.getFields(); + } else { + RowData rd = new RowData(row, metaTable, titleColumns); + mapRows.put(rd); + i++; + } + flag = true; + } + } catch (Throwable ex){ + ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance().getValue("general", "meta", "loadRow").withParams(String.valueOf(i) ), messageLevel); + warnFilesNotFound(); + throw ex; + } + ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "meta", "loadedRow").withParams(String.valueOf(i) ), messageLevel); + warnFilesNotFound(); + + return this; + } + + + @Override + public IMetaObject deSerialize(InputStream stream) throws Exception { + + MetaTable metaTable = getMetaTableFromFile(); + + CSVParser csvParser = new CSVParser(new InputStreamReader(stream), getCSVFormat()); + List csvRecords = csvParser.getRecords(); + + if (csvRecords.size() > 0) { + CSVRecord titleColumns = csvRecords.get(0); + fields.clear(); + for (int i = 0; i < csvRecords.get(0).size(); i++) { + fields.add(csvRecords.get(0).get(i)); + } + + mapRows = new TreeMapRowData(); + + for (int i = 1; i < csvRecords.size(); i++) { + RowData rd = new RowData(csvRecords.get(i), metaTable, titleColumns); + mapRows.put(rd); + } + } + + + csvParser.close(); + + //saveToFile("test"); + + return this; + } + + public boolean loadPortionFromDB(int currentPortionIndex) throws ExceptionDBGit { + return loadPortionFromDB(currentPortionIndex, 0); + } + + public boolean loadPortionFromDB(int currentPortionIndex, int tryNumber) throws ExceptionDBGit { + try { + IDBAdapter adapter = AdapterFactory.createAdapter(); + MetaTable metaTable = getMetaTable(); + if (metaTable.getFields().size() == 0) + return false; + + dataTable = adapter.getTableDataPortion(table.getSchema(), table.getName(), currentPortionIndex, 0); + + ResultSet rs = dataTable.getResultSet(); + + if (dataTable.getErrorFlag() > 0) { + ConsoleWriter.printlnColor(DBGitLang.getInstance().getValue("errors", "meta", "tooManyRecords"). + withParams(getName(), String.valueOf(IDBAdapter.MAX_ROW_COUNT_FETCH)), FColor.RED, 0); + return false; + } + + mapRows = new TreeMapRowData(); + + boolean flag = false; + while(rs.next()){ + + if (!flag) { + fields.clear(); + for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) { + String columnName = rs.getMetaData().getColumnName(i + 1); + if (columnName.equalsIgnoreCase("DBGIT_ROW_NUM")) + continue; + fields.add(columnName); + } + } + + flag = true; + RowData rd = new RowData(rs, metaTable); + mapRows.put(rd); + } + + + + return true; + } catch (Exception e) { + + ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); + ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); + logger.error(DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(), e); + + try { + if (tryNumber <= DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000))) { + try { + TimeUnit.SECONDS.sleep(DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000))); + } catch (InterruptedException e1) { + throw new ExceptionDBGitRunTime(e1.getMessage()); + } + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "dataTable", "loadPortionError") + .withParams(String.valueOf(tryNumber)) + , messageLevel + ); + return loadPortionFromDB(currentPortionIndex, tryNumber++); + } + } catch (Exception e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } + + if (e instanceof ExceptionDBGit) throw (ExceptionDBGit)e; + throw new ExceptionDBGit(e); + } + } + + @Override + public boolean loadFromDB() throws ExceptionDBGit { + try { + IDBAdapter adapter = AdapterFactory.createAdapter(); + + MetaTable metaTable = getMetaTable(); + + if (metaTable.getFields().size() == 0) + return false; + + dataTable = adapter.getTableData(table.getSchema(), table.getName()); + + if (dataTable.getErrorFlag() > 0) { + ConsoleWriter.printlnColor(DBGitLang.getInstance().getValue("errors", "meta", "tooManyRecords"). + withParams(getName(), String.valueOf(IDBAdapter.MAX_ROW_COUNT_FETCH)), FColor.RED, 0); + return false; + } + + ResultSet rs = dataTable.getResultSet(); + + mapRows = new TreeMapRowData(); + + //System.out.println("load from db file "+getName()); + while(rs.next()){ + RowData rd = new RowData(rs, metaTable); + mapRows.put(rd); + } + return true; + /* + System.out.println("******************************************"); + System.out.println(); + */ + } catch (Exception e) { + e.printStackTrace(); + if (e instanceof ExceptionDBGit) + throw (ExceptionDBGit)e; + throw new ExceptionDBGit(e); + } + + } + + public void diff(MetaTableData ob) throws Exception { + if (mapRows.size() != ob.mapRows.size()) { + System.out.println(DBGitLang.getInstance().getValue("general", "meta", "diffSize1").withParams(String.valueOf(mapRows.size()), String.valueOf(ob.mapRows.size()))); + } + for (String rowHash : mapRows.keySet()) { + RowData r1 = mapRows.get(rowHash); + RowData r2 = ob.mapRows.get(rowHash); + + System.out.println(rowHash); + System.out.println(r1.getData(fields)+ " "+ r2.getData(ob.fields)); + + if (r1.getData(fields).size() != r2.getData(ob.fields).size()) { + System.out.println(DBGitLang.getInstance().getValue("general", "meta", "diffSize2").withParams(rowHash)); + } + + for (String col : r1.getData(fields).keySet()) { + String d1 = r1.getData(fields).get(col).convertToString(); + String d2 = r2.getData(ob.fields).get(col).convertToString(); + + if (d1 != d2) { + if (!d1.equals(r2.getData(ob.fields).get(col))) { + System.out.println(DBGitLang.getInstance().getValue("general", "meta", "diffDataRow"). + withParams(rowHash, col, r1.getData(fields).get(col).toString(), r2.getData(ob.fields).get(col).toString())); + } + } + } + } + } + + + @Override + public String getHash() { + CalcHash ch = new CalcHash(); + if (mapRows == null) + return EMPTY_HASH; + + if (mapRows.size() == 0) + return EMPTY_HASH; + + //System.out.println(getName()); + int n = 0; + for (RowData rd : mapRows.values()) { + ch.addData(rd.getHashRow()); + //System.out.println("row "+n+" "+rd.getHashRow()); + n++; + } + + return ch.calcHashStr(); + } + + @Override + public int addToGit() throws ExceptionDBGit { + int count = super.addToGit(); + + if (mapRows == null) return count; + + for (RowData rd : mapRows.values()) { + for (ICellData cd : rd.getData(fields).values()) { + count += cd.addToGit(); + } + } + + return count; + } + + @Override + public int removeFromGit() throws ExceptionDBGit { + int count = super.removeFromGit(); + + if (mapRows == null) + return 1; + + for (RowData rd : mapRows.values()) { + for (ICellData cd : rd.getData(fields).values()) { + count += cd.removeFromGit(); + } + } + + return count; + } + + public List getFields() { + return fields; + } + + private void warnFilesNotFound(){ + Set filesNotFound = MapFileData.getFilesNotFound(); + if(filesNotFound != null && filesNotFound.size() > 0){ + ConsoleWriter.detailsPrintlnColor(DBGitLang.getInstance().getValue("errors", "dataTable", "filesNotFound") + .withParams(String.join(";", filesNotFound)) + , FColor.YELLOW, messageLevel + ); + filesNotFound.clear(); + } + + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java index fa60373..b2a2f52 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java @@ -163,8 +163,11 @@ public List sortFromReferenced() throws ExceptionDBGit { }; public void warnNotAdded(List remained){ - ConsoleWriter.detailsPrintlnRed("There were objects with unsatisfied dependencies, " + - "they will NOT be included in restore list!\n"); + ConsoleWriter.printlnRed(DBGitLang.getInstance() + .getValue("errors", "unsatisfiedDependencies") + , 1 + ); + remained.forEach( x -> ConsoleWriter.printlnColor(x.getName(), Ansi.FColor.MAGENTA, 1) ); } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java index 2d0c983..b630b9b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java @@ -6,6 +6,7 @@ import ru.fusionsoft.dbgit.adapters.IFactoryDBBackupAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; import ru.fusionsoft.dbgit.core.DBGitConfig; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.core.db.DbType; @@ -947,8 +948,11 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port return data; } catch (Exception e) { - ConsoleWriter.println("Connection lost!"); - ConsoleWriter.println("Error while getting portion of data, try " + tryNumber); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "dataTable", "loadPortionError") + .withParams(String.valueOf(tryNumber)) + , messageLevel + ); logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); //try fetch again diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBBackupAdapterMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBBackupAdapterMssql.java index 7c8b765..27e5ee0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBBackupAdapterMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBBackupAdapterMssql.java @@ -43,7 +43,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio createSchema(stLog, schema); } - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); ddl = ddl.replace(schema + "." + objectName, getFullDbName(schema, objectName)); @@ -77,7 +77,7 @@ else if (obj instanceof MetaTable) { createSchema(stLog, schema); } - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); dropIfExists(isSaveToSchema() ? PREFIX + schema : schema, isSaveToSchema() ? objectName : PREFIX + objectName, stLog); @@ -138,7 +138,7 @@ else if (obj instanceof MetaSequence) { String sequenceName = getFullDbName(schema, objectName); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); StringProperties props = metaSequence.getSequence().getOptions(); String seqName = props.get("name").getData(); @@ -185,10 +185,9 @@ else if (obj instanceof MetaSequence) { throw new ExceptionDBGitRestore( lang.getValue("errors", "restore", "objectRestoreError") .withParams(obj.getName() + ": " + e1.getLocalizedMessage()) + , e1 ); } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - connection.rollback(); throw new ExceptionDBGit(lang.getValue("errors", "backup", "backupError").withParams(obj.getName()), e); } finally { stLog.close(); @@ -285,12 +284,12 @@ public boolean isExists(String owner, String objectName) throws SQLException { public boolean createSchema(StatementLogging stLog, String schema) { try { if (!adapter.getSchemes().containsKey(schema)) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), messageLevel); stLog.execute(MessageFormat.format("CREATE SCHEMA {0}{1}", PREFIX, schema)); } return true; } catch (SQLException e) { - ConsoleWriter.println(lang.getValue("errors", "backup", "cannotCreateSchema").withParams(e.getLocalizedMessage())); + ConsoleWriter.println(lang.getValue("errors", "backup", "cannotCreateSchema").withParams(e.getLocalizedMessage()), messageLevel); return false; } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreFunctionMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreFunctionMssql.java index 5fb010d..3bde897 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreFunctionMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreFunctionMssql.java @@ -52,11 +52,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "function", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreProcedureMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreProcedureMssql.java index b7bafa1..5e50e36 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreProcedureMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreProcedureMssql.java @@ -45,13 +45,14 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "procedure", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreRoleMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreRoleMssql.java index 06a46ad..e8be46f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreRoleMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreRoleMssql.java @@ -59,11 +59,13 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { connect.commit(); } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "role", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail"), 0); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java index fdec25b..7e30211 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java @@ -48,11 +48,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "schema", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSequenceMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSequenceMssql.java index b84b134..5b48f14 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSequenceMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSequenceMssql.java @@ -79,11 +79,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "sequence", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java index ce7256b..70c6498 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java @@ -93,14 +93,17 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - //TODO WTF???? - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - //return true; + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data cached", obj.getType().getValue() + )); } } - else - { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + else { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data", obj.getType().getValue() + )); } } @@ -134,7 +137,7 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData if(!diffTableData.entriesOnlyOnLeft().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "inserting"), messageLevel); for(RowData rowData:diffTableData.entriesOnlyOnLeft().values()) { ArrayList fieldsList = new ArrayList(rowData.getData().keySet()); @@ -142,14 +145,14 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData String insertQuery = "insert into "+tblName + fields+valuesToString(rowData.getData().values(), colTypes, fieldsList) + ";\n"; - ConsoleWriter.detailsPrintLn(insertQuery); + ConsoleWriter.detailsPrintln(insertQuery, messageLevel+1); PrepareStatementLogging ps = new PrepareStatementLogging(connect, insertQuery, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); int i = 0; for (ICellData data : rowData.getData().values()) { i++; - ConsoleWriter.detailsPrintLn(data.getSQLData()); + ConsoleWriter.detailsPrintln(data.getSQLData(), messageLevel+1); ResultSet rs = st.executeQuery("select data_type from information_schema.columns \r\n" + "where lower(table_schema||'.'||table_name) = lower('" + tblName + "') and lower(column_name) = '" + fieldsList.get(i - 1) + "'"); @@ -174,7 +177,7 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData } if(!diffTableData.entriesOnlyOnRight().isEmpty()){ - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); String deleteQuery=""; Map primarykeys = new HashMap(); for(RowData rowData:diffTableData.entriesOnlyOnRight().values()) { @@ -216,7 +219,7 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData } if(!diffTableData.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "updating"), messageLevel); String updateQuery=""; Map primarykeys = new HashMap(); for(ValueDifference diffRowData:diffTableData.entriesDiffering().values()) { @@ -265,15 +268,15 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData updateQuery="update "+tblName+ " set "+updFields + " = " + valuesToString(tempCols.values(), colTypes, fieldsList) + " where " + keyFields+ "=" +keyValues+";\n"; - ConsoleWriter.detailsPrintLn(updateQuery); + ConsoleWriter.detailsPrintln(updateQuery, messageLevel+1); PrepareStatementLogging ps = new PrepareStatementLogging(connect, updateQuery, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); int i = 0; - ConsoleWriter.detailsPrintLn("vals for " + keyValues + ":" + diffRowData.leftValue().getData().values()); + ConsoleWriter.detailsPrintln("vals for " + keyValues + ":" + diffRowData.leftValue().getData().values(), messageLevel); for (ICellData data : diffRowData.leftValue().getData().values()) { i++; - ConsoleWriter.detailsPrintLn(data.getSQLData()); + ConsoleWriter.detailsPrintln(data.getSQLData(), messageLevel+1); ResultSet rs = st.executeQuery("select data_type from information_schema.columns \r\n" + "where lower(table_schema||'.'||table_name) = lower('" + tblName + "') and lower(column_name) = '" + fieldsList.get(i - 1) + "'"); @@ -306,13 +309,12 @@ public void restoreTableDataMssql(MetaTableData restoreTableData, MetaTableData } ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); if(updateQuery.length()>1) { - ConsoleWriter.println(updateQuery); + ConsoleWriter.println(updateQuery, messageLevel+1); st.execute(updateQuery); } } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()), e); } finally { st.close(); @@ -446,7 +448,7 @@ public String keysToString(Set keys) { } public void restoreTableConstraintMssql(MetaTable table) throws Exception { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), messageLevel); IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -459,8 +461,6 @@ public void restoreTableConstraintMssql(MetaTable table) throws Exception { } } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(schema + "." + table.getTable().getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); @@ -476,7 +476,7 @@ public void removeTableConstraintsMssql(MetaTable table) throws Exception { String schema = getPhisicalSchema(table.getTable().getSchema()); schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema + "." +table.getTable().getName(); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), messageLevel); try { //TODO MSSQL remove table constraints script ResultSet rs = stCnt.executeQuery("SELECT *\r\n" + @@ -508,8 +508,6 @@ public void removeTableConstraintsMssql(MetaTable table) throws Exception { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "cannotRestore").withParams(schema + "." + table.getTable().getName()), e); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java index 17cee06..2d6ceda 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java @@ -56,7 +56,7 @@ public void restoreTableMssql(IMetaObject obj) throws Exception { if(!isTablePresent(tblSchema ,tblName)){ - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "createTable"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "createTable"), messageLevel); DBTable table = restoreTable.getTable(); @@ -83,12 +83,13 @@ public void restoreTableMssql(IMetaObject obj) throws Exception { restoreTablePksMssql(restoreTable, st); } } - else - { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + else { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); @@ -99,7 +100,7 @@ public void restoreTableIndexesMssql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), messageLevel); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -164,21 +165,17 @@ public void restoreTableIndexesMssql(IMetaObject obj) throws Exception { st.execute(ind.getSql()); }*/ String errText = lang.getValue("errors", "meta", "notFound").withParams(obj.getName()); - ConsoleWriter.detailsPrintlnRed(errText); throw new ExceptionDBGitRestore(errText); } } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { -// ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -187,7 +184,7 @@ private void restoreTableConstraintMssql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), messageLevel); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -210,12 +207,12 @@ private void restoreTableConstraintMssql(IMetaObject obj) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); @@ -242,7 +239,6 @@ public void removeMetaObject(IMetaObject obj) throws Exception { ); } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); } finally { st.close(); @@ -272,7 +268,7 @@ private void restoreTableFieldsMssql(MetaTable restoreTable, String tblName, Str if( !restoringUniqueFields.isEmpty()){ - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "addColumns"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "addColumns"), messageLevel); List values = restoringUniqueFields.values() .stream() @@ -288,7 +284,7 @@ private void restoreTableFieldsMssql(MetaTable restoreTable, String tblName, Str } if( !existingUniqueFields.isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "droppingColumns"), messageLevel); for(DBTableField tblField:existingUniqueFields.values()) { String fieldDdl = MessageFormat.format("ALTER TABLE {1} DROP COLUMN [{2}]", tblSam, tblField.getName()); @@ -299,7 +295,7 @@ private void restoreTableFieldsMssql(MetaTable restoreTable, String tblName, Str } if(!mergingFields.isEmpty()) { - ConsoleWriter.detailsPrintLnColor(lang.getValue("general", "restore", "modifyColumns"), 3, Ansi.FColor.WHITE); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "modifyColumns"), messageLevel); for(ValueDifference fld : mergingFields.values()) { DBTableField oldValue = fld.rightValue(); @@ -346,10 +342,12 @@ private void removeTableConstraintsMssql(IMetaObject obj) throws Exception { } else { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } } @@ -360,7 +358,7 @@ private boolean getIsPk(DBConstraint dbConstraint){ } private void restoreTablePksMssql(MetaTable restoreTable, StatementLogging st) throws SQLException { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "addPk"), messageLevel); String tblSchema = restoreTable.getTable().getSchema(); String tblName = restoreTable.getTable().getName(); boolean flagPkCreated = false; @@ -389,7 +387,7 @@ private void restoreTablePksMssql(MetaTable restoreTable, StatementLogging st) t if (!flagPkCreated) { for(DBTableField field: restoreTable.getFields().values()) { if (field.getIsPrimaryKey()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "addPk"), messageLevel); String ddl = MessageFormat.format( "ALTER TABLE {0} ADD CONSTRAINT PK_{1}_{2} PRIMARY KEY([{2}])", diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java index c88c769..ff9f34b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java @@ -67,12 +67,16 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "tablespace", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError") + .withParams(obj.getName()) + , e + ); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTriggerMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTriggerMssql.java index acde79e..dcd0a3e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTriggerMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTriggerMssql.java @@ -55,19 +55,20 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if(!ddl.isEmpty()){ st.execute(ddl); } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "encrypted").withParams(triggerName)); + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "encrypted").withParams(triggerName), messageLevel); } } } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "trigger", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreUserMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreUserMssql.java index 78327f6..d757fa3 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreUserMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreUserMssql.java @@ -59,11 +59,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "user", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java index be6332f..1cb046e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java @@ -53,8 +53,10 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "view", obj.getType().getValue() + )); } } catch (Exception e) { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/FactoryDBAdapterRestoreMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/FactoryDBAdapterRestoreMssql.java index 2fd0405..c80150e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/FactoryDBAdapterRestoreMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/FactoryDBAdapterRestoreMssql.java @@ -41,7 +41,7 @@ public class FactoryDBAdapterRestoreMssql implements IFactoryDBAdapterRestoteMet public IDBAdapterRestoreMetaData getAdapterRestore(IDBGitMetaType tp, IDBAdapter adapter) { if (!restoreAdapters.containsKey(tp.getValue())) { //return new DBRestoreMetaNotSupport(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "restore", "cannotRestore").withParams(tp.getValue())); + ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "restore", "cannotRestore").withParams(tp.getValue()), messageLevel); return null; } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/FactoryDbConvertAdapterMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/FactoryDbConvertAdapterMssql.java index 4d6748d..d20e7b3 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/FactoryDbConvertAdapterMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/FactoryDbConvertAdapterMssql.java @@ -2,6 +2,7 @@ import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.meta.DBGitMetaType; import ru.fusionsoft.dbgit.mssql.converters.TableConverterMssql; import ru.fusionsoft.dbgit.mssql.converters.TableDataConverterMssql; @@ -26,7 +27,11 @@ public class FactoryDbConvertAdapterMssql implements IFactoryDBConvertAdapter { @Override public IDBConvertAdapter getConvertAdapter(String objectType) throws Exception { if (!converters.containsKey(objectType)) { - ConsoleWriter.println("Cannot convert " + objectType + "!"); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "convert", "cannotConvert") + .withParams(objectType) + , 1 + ); return null; } else return converters.get(objectType); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java index 1169ffb..28e0c2e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java @@ -569,14 +569,9 @@ public DBTableData getTableData(String schema, String nameTable) { return data; } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - try { - getConnection().rollback(); - } catch (Exception e2) { - logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); - } - throw new ExceptionDBGitRunTime(e.getMessage()); + throw new ExceptionDBGitRunTime(e); } + return data; } @Override @@ -724,6 +719,9 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port data.setResultSet(rs); return data; } catch(Exception e) { + + ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); + ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); try { @@ -733,7 +731,11 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port } catch (InterruptedException e1) { throw new ExceptionDBGitRunTime(e1.getMessage()); } - ConsoleWriter.println("Error while getting portion of data, try " + tryNumber); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "dataTable", "loadPortionError") + .withParams(String.valueOf(tryNumber)) + , messageLevel + ); getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); } } catch (Exception e1) { diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java index 48430d5..d5556ab 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBBackupAdapterMySql.java @@ -36,7 +36,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { if (isSaveToSchema()) { createSchema(stLog, schema); } - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); ////dropIfExists(isSaveToSchema() ? PREFIX + schema : schema, //// isSaveToSchema() ? objectName : PREFIX + objectName, stLog); //ddl = ddl.replace(schema + "." + objectName, getFullDbName(schema, objectName)); @@ -64,7 +64,9 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { if (isSaveToSchema()) { createSchema(stLog, schema); } - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)) + , messageLevel + ); //dropIfExists( //isSaveToSchema() ? PREFIX + schema : schema, //isSaveToSchema() ? tableName : PREFIX + tableName, stLog @@ -118,7 +120,9 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { createSchema(stLog, schema); } String sequenceName = getFullDbName(schema, objectName); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)) + , messageLevel + ); //String ddl = "create sequence " + sequenceName + "\n" //+ (metaSequence.getSequence().getOptions().get("cycle_option").toString().equals("YES") ? "CYCLE\n" : "") //+ " INCREMENT " + metaSequence.getSequence().getOptions().get("increment").toString() + "\n" @@ -136,12 +140,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws Exception { obj = metaSequence.loadFromFile(); ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } - } catch (SQLException e1) { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError"). - withParams(obj.getName() + ": " + e1.getLocalizedMessage())); } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - connection.rollback(); throw new ExceptionDBGitRestore(lang.getValue("errors", "backup", "backupError").withParams(obj.getName()), e); } finally { connection.commit(); @@ -223,7 +222,7 @@ public boolean createSchema(StatementLogging stLog, String schema) { rs.next(); if (rs.getInt("cnt") == 0) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), messageLevel); stLog.execute("create schema " + PREFIX + schema); } @@ -232,7 +231,7 @@ public boolean createSchema(StatementLogging stLog, String schema) { return true; } catch (SQLException e) { - ConsoleWriter.println(lang.getValue("errors", "backup", "cannotCreateSchema").withParams(e.getLocalizedMessage())); + ConsoleWriter.println(lang.getValue("errors", "backup", "cannotCreateSchema").withParams(e.getLocalizedMessage()), messageLevel); return false; } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java index 7431453..a415ac5 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java @@ -22,8 +22,11 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { MetaSchema restoreSchema = (MetaSchema) obj; st.execute("CREATE SCHEMA IF NOT EXISTS " + restoreSchema.getObjectOption().getName()); } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "schema", obj.getType().getValue() + )); } } catch (Exception e) { ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java index 2eaec06..9b2befe 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java @@ -75,12 +75,16 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } return true; } else { - ////TODO WTF???? - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - //return true; + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data cached", obj.getType().getValue() + )); } } else { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data", obj.getType().getValue() + )); } } @@ -101,18 +105,18 @@ public void restoreTableDataMySql(MetaTableData restoreTableData, MetaTableData schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema + ".`" + restoreTableData.getTable().getName() + "`"; if (!diffTableData.entriesOnlyOnLeft().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "inserting"), messageLevel); for (RowData rowData : diffTableData.entriesOnlyOnLeft().values()) { String fields = String.join("`, `", rowData.getData().keySet()); String values = String.join(", ", rowData.getData().values().stream().map(row -> valueToString(row)).collect(Collectors.toList())); String insertQuery = "insert into " + tblName + "(`" + fields + "`) values (" + values + ");"; - ConsoleWriter.detailsPrintLn(insertQuery); + ConsoleWriter.detailsPrintln(insertQuery, messageLevel); st.execute(insertQuery); } ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if (!diffTableData.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); String ddl = ""; for (RowData rowData : diffTableData.entriesOnlyOnRight().values()) { Map primarykeys = new HashMap(); @@ -138,7 +142,7 @@ public void restoreTableDataMySql(MetaTableData restoreTableData, MetaTableData ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } if (!diffTableData.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "updating"), messageLevel); String updateQuery = ""; //Map primarykeys = new HashMap(); for (ValueDifference diffRowData : diffTableData.entriesDiffering().values()) { @@ -213,12 +217,12 @@ public void restoreTableDataMySql(MetaTableData restoreTableData, MetaTableData } ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); if (!updateQuery.isEmpty()) { - ConsoleWriter.println(updateQuery); + //TODO not a real restore, just print + ConsoleWriter.println(updateQuery, messageLevel); //st.execute(updateQuery); } } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java index e68517a..9efd6fa 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java @@ -54,7 +54,7 @@ public void removeMetaObject(IMetaObject obj) throws Exception { schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); st.execute("drop table if exists " + schema + "." + tbl.getName()); } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); + ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage()), 0); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); } finally { st.close(); @@ -97,10 +97,12 @@ public void restoreTableMySql(IMetaObject obj) throws Exception { st.execute(ddl); ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); @@ -111,7 +113,7 @@ public void restoreTableIndexesMySql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), messageLevel); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -171,19 +173,18 @@ public void restoreTableIndexesMySql(IMetaObject obj) throws Exception { //} } else { String errText = lang.getValue("errors", "meta", "notFound").withParams(obj.getName()); - ConsoleWriter.detailsPrintlnRed(errText); throw new ExceptionDBGitRestore(errText); } } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { -// ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -192,7 +193,7 @@ private void restoreTableConstraintMySql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), messageLevel); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -224,13 +225,13 @@ private void restoreTableConstraintMySql(IMetaObject obj) throws Exception { } } } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreUserMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreUserMySql.java index fb603b8..4110a4b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreUserMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreUserMySql.java @@ -23,11 +23,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "user", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java index 9cd4999..5b0a917 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java @@ -24,11 +24,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { st.execute(ddl); //connect.commit();//FIXME ???? } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "view", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/FactoryDBConvertAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/FactoryDBConvertAdapterMySql.java index b3444e0..3e42fa1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/FactoryDBConvertAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/FactoryDBConvertAdapterMySql.java @@ -2,6 +2,7 @@ import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.meta.DBGitMetaType; import ru.fusionsoft.dbgit.mysql.converters.*; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -27,7 +28,11 @@ public class FactoryDBConvertAdapterMySql implements IFactoryDBConvertAdapter { @Override public IDBConvertAdapter getConvertAdapter(String objectType) throws Exception { if (!converters.containsKey(objectType)) { - ConsoleWriter.println("Cannot convert " + objectType + "!"); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "convert", "cannotConvert") + .withParams(objectType) + , 1 + ); return null; } else return converters.get(objectType); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/FactoryDBRestoreAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/FactoryDBRestoreAdapterMySql.java index b55d02f..93a657d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/FactoryDBRestoreAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/FactoryDBRestoreAdapterMySql.java @@ -37,7 +37,7 @@ public class FactoryDBRestoreAdapterMySql implements IFactoryDBAdapterRestoteMet public IDBAdapterRestoreMetaData getAdapterRestore(IDBGitMetaType tp, IDBAdapter adapter) { if (!restoreAdapters.containsKey(tp.getValue())) { //return new DBRestoreMetaNotSupport(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "restore", "cannotRestore").withParams(tp.getValue())); + ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "restore", "cannotRestore").withParams(tp.getValue()), messageLevel); return null; } diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/converters/SchemaConverterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/converters/SchemaConverterMySql.java index 030c440..10a7453 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/converters/SchemaConverterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/converters/SchemaConverterMySql.java @@ -2,6 +2,7 @@ import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; import ru.fusionsoft.dbgit.core.DBConnection; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.meta.IMetaObject; @@ -17,7 +18,11 @@ public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) thr if (obj instanceof MetaSchema) { MetaSchema schema = (MetaSchema) obj; schema.setDbType(DbType.MYSQL); - ConsoleWriter.println("Processing schema " + schema.getName()); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingSchema") + .withParams(schema.getName()) + , messageLevel + ); //ConsoleWriter.printlnGreen("URL=" + DBConnection.getInstance().dbName); switch(objDbType) { case POSTGRES: diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/converters/TableConverterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/converters/TableConverterMySql.java index fa38060..d0081f9 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/converters/TableConverterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/converters/TableConverterMySql.java @@ -21,7 +21,11 @@ public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) thr return obj; if (obj instanceof MetaTable) { MetaTable table = (MetaTable) obj; - ConsoleWriter.println("Processing table " + table.getName()); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "processingTable") + .withParams(table.getName()) + , messageLevel + ); //types for (DBTableField field : table.getFields().values()) field.setTypeSQL(typeFromAnotherDB(objDbType, field)); @@ -56,17 +60,29 @@ public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) thr } private String indexFromPostgres(DBIndex index) { - ConsoleWriter.println("Converting table index " + index.getName() + " from postgresql to mysql..."); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingIndex") + .withParams(index.getName(), "postgresql", "mysql") + , messageLevel + ); return ""; } private String indexFromOracle(DBIndex index) { - ConsoleWriter.println("Converting table index " + index.getName() + " from oracle to mysql..."); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingIndex") + .withParams(index.getName(), "oracle", "mysql") + , messageLevel + ); return ""; } private String constraintFromOracle(DBConstraint constraint) {//TODO: change - ConsoleWriter.println("Converting table constraint " + constraint.getName() + " from oracle to mysql..."); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingConstraint") + .withParams(constraint.getName(), "oracle", "mysql") + , messageLevel + ); Pattern patternConstraint = Pattern.compile("(?<=" + constraint.getName() + ")(.*?)(?=\\))", Pattern.MULTILINE); Matcher matcher = patternConstraint.matcher(constraint.getSql()); if (matcher.find()) @@ -76,7 +92,11 @@ private String constraintFromOracle(DBConstraint constraint) {//TODO: change } private String constraintFromPostgres(MetaTable table, DBConstraint constraint) {//TODO: change - ConsoleWriter.println("Converting table constraint " + constraint.getName() + " from postgresql to mysql..."); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingConstraint") + .withParams(constraint.getName(), "postgresql", "mysql") + , messageLevel + ); String ddl = constraint.getOptions().get("ddl") .toString() @@ -92,7 +112,11 @@ private String constraintFromPostgres(MetaTable table, DBConstraint constraint) } private String typeFromAnotherDB(DbType dbType, DBTableField field) { - ConsoleWriter.println("Converting table field " + field.getName() + " from " + dbType.toString().toLowerCase() + " to mysql..."); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingField") + .withParams(field.getName(), dbType.toString().toLowerCase(), "mysql") + , messageLevel + ); String result; switch (field.getTypeUniversal()) { case STRING: diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/converters/ViewConverterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/converters/ViewConverterMySql.java index 3209836..2f4deff 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/converters/ViewConverterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/converters/ViewConverterMySql.java @@ -1,6 +1,7 @@ package ru.fusionsoft.dbgit.mysql.converters; import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.meta.IMetaObject; @@ -17,7 +18,11 @@ public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) thr if (obj instanceof MetaView) { MetaView view = (MetaView) obj; view.setDbType(DbType.MYSQL); - ConsoleWriter.println("Processing view " + view.getName()); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingView") + .withParams(view.getName()) + , messageLevel + ); switch(objDbType) { case POSTGRES: String ddl = view.getSqlObject().getSql(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java index bf595c5..a1653ca 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java @@ -12,6 +12,7 @@ import java.util.concurrent.TimeUnit; import java.util.Set; +import org.apache.commons.lang3.exception.ExceptionUtils; import ru.fusionsoft.dbgit.adapters.DBAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapterRestoreMetaData; @@ -138,7 +139,7 @@ public Map getTableSpaces() { stmt.close(); }catch(Exception e) { logger.error(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); + throw new ExceptionDBGitRunTime(e); } return listTableSpace; } @@ -451,22 +452,21 @@ public DBView getView(String schema, String name) { }catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "views").toString() + ": "+ e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views").toString() + ": "+ e.getMessage()); + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views").toString(), e); } } public Map getTriggers(String schema) { + Map listTrigger = new HashMap(); - try { - String query = "SELECT tr.owner, tr.trigger_name, tr.trigger_type, tr.table_name," + - " (select dbms_metadata.get_ddl('TRIGGER', tr.trigger_name, tr.owner) AS DDL from dual) AS DDL\n" + - "FROM all_triggers tr\n" + - "WHERE owner = '"+ schema +"'"; - - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - - ResultSet rs = stmt.executeQuery(query); + String query = + "SELECT tr.owner, tr.trigger_name, tr.trigger_type, tr.table_name," + + " (select dbms_metadata.get_ddl('TRIGGER', tr.trigger_name, tr.owner) AS DDL from dual) AS DDL\n" + + "FROM all_triggers tr\n" + + "WHERE owner = '"+ schema +"'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while(rs.next()){ String name = rs.getString("TRIGGER_NAME"); String sql = rs.getString("DDL"); @@ -477,22 +477,24 @@ public Map getTriggers(String schema) { rowToProperties(rs, trigger.getOptions()); listTrigger.put(name, trigger); } - stmt.close(); - return listTrigger; - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); + + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); } + + return listTrigger; } public DBTrigger getTrigger(String schema, String name) { DBTrigger trigger = null; - try { - String query = "SELECT tr.owner, tr.trigger_name, tr.trigger_type, tr.table_name, (select dbms_metadata.get_ddl('TRIGGER', tr.trigger_name, tr.owner) AS DDL from dual) AS DDL\n" + - "FROM all_triggers tr\n" + - "WHERE owner = '" + schema + "' and trigger_name = '" + name + "'"; - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + + String query = + "SELECT tr.owner, tr.trigger_name, tr.trigger_type, tr.table_name, (select dbms_metadata.get_ddl('TRIGGER', tr.trigger_name, tr.owner) AS DDL from dual) AS DDL\n" + + "FROM all_triggers tr\n" + + "WHERE owner = '" + schema + "' and trigger_name = '" + name + "'"; + + try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ trigger = new DBTrigger(name); @@ -501,22 +503,24 @@ public DBTrigger getTrigger(String schema, String name) { trigger.setOwner("oracle"); rowToProperties(rs, trigger.getOptions()); } - stmt.close(); - return trigger; - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); } + + return trigger; } @Override public Map getPackages(String schema) { Map listPackage = new HashMap(); - try { - String query = "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('PACKAGE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PACKAGE'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + + String query = + "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('PACKAGE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PACKAGE'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query); ){ + while(rs.next()){ String name = rs.getString("OBJECT_NAME"); String owner = rs.getString("OWNER"); @@ -528,23 +532,24 @@ public Map getPackages(String schema) { //pack.setArguments(args); listPackage.put(name, pack); } - stmt.close(); - }catch(Exception e) { + + } catch(Exception e) { throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "pkg").toString(), e); } + return listPackage; } @Override public DBPackage getPackage(String schema, String name) { - try { - String query = "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('PACKAGE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PACKAGE' and f.object_name = '" + name + "'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - - DBPackage pack = null; + DBPackage pack = null; + + String query = + "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('PACKAGE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PACKAGE' and f.object_name = '" + name + "'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while (rs.next()) { pack = new DBPackage(name); String owner = rs.getString("OWNER"); @@ -554,25 +559,25 @@ public DBPackage getPackage(String schema, String name) { //pack.setArguments(args); rowToProperties(rs,pack.getOptions()); } - stmt.close(); - - return pack; - - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views").toString(), e); + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views").toString(), e); } + + return pack; } @Override public Map getProcedures(String schema) { Map listProcedure = new HashMap(); - try { - String query = "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + - "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('PROCEDURE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PROCEDURE'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + + String query = + "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + + "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('PROCEDURE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PROCEDURE'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while(rs.next()){ String name = rs.getString("OBJECT_NAME"); String owner = rs.getString("OWNER"); @@ -585,24 +590,25 @@ public Map getProcedures(String schema) { //proc.setArguments(args); listProcedure.put(name, proc); } - stmt.close(); - }catch(Exception e) { + + } catch(Exception e) { throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); } + return listProcedure; } @Override public DBProcedure getProcedure(String schema, String name) { - try { - String query = "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + - "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('PROCEDURE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PROCEDURE' and f.object_name = '" + name + "'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - DBProcedure proc = null; - + DBProcedure proc = null; + + String query = + "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + + "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('PROCEDURE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PROCEDURE' and f.object_name = '" + name + "'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while (rs.next()) { proc = new DBProcedure(rs.getString("OBJECT_NAME")); String owner = rs.getString("OWNER"); @@ -612,25 +618,23 @@ public DBProcedure getProcedure(String schema, String name) { //proc.setArguments(args); rowToProperties(rs,proc.getOptions()); } - stmt.close(); - - return proc; - - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); } + + return proc; } @Override public Map getFunctions(String schema) { Map listFunction = new HashMap(); - try { - String query = "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS \r\n" + - "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('FUNCTION', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'FUNCTION'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS \r\n" + + "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('FUNCTION', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'FUNCTION'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ String name = rs.getString("OBJECT_NAME"); String sql = rs.getString("DDL"); @@ -643,25 +647,26 @@ public Map getFunctions(String schema) { //func.setArguments(args); listFunction.put(name, func); } - stmt.close(); - }catch(Exception e) { + + } catch(Exception e) { throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); } + return listFunction; } @Override public DBFunction getFunction(String schema, String name) { - try { - String query = "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + - "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('FUNCTION', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema +"' and " + - "f.object_type = 'FUNCTION' and f.object_name = '" + name +"'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - DBFunction func = null; - + DBFunction func = null; + + String query = + "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + + "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('FUNCTION', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + + "FROM all_objects f WHERE f.owner = '" + schema +"' and " + + "f.object_type = 'FUNCTION' and f.object_name = '" + name +"'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while (rs.next()) { func = new DBFunction(rs.getString("OBJECT_NAME")); String owner = rs.getString("OWNER"); @@ -671,13 +676,12 @@ public DBFunction getFunction(String schema, String name) { //func.setArguments(args); rowToProperties(rs,func.getOptions()); } - stmt.close(); - - return func; - - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); } + + return func; } @Override @@ -697,7 +701,9 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port data.setResultSet(rs); return data; } catch(Exception e) { - ConsoleWriter.println("Connection lost!"); + + ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); + ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); try { @@ -707,7 +713,11 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port } catch (InterruptedException e1) { throw new ExceptionDBGitRunTime(e1.getMessage()); } - ConsoleWriter.println("Error while getting portion of data, try " + tryNumber); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "dataTable", "loadPortionError") + .withParams(String.valueOf(tryNumber)) + , messageLevel + ); return getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); } } catch (Exception e1) { diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBBackupAdapterOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBBackupAdapterOracle.java index f0c3946..c896ff0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBBackupAdapterOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBBackupAdapterOracle.java @@ -30,7 +30,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio String ddl = metaSql.getSqlObject().getSql(); String schema = metaSql.getSqlObject().getSchema(); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); ddl = replaceNames(ddl, schema, objectName, stLog); @@ -64,7 +64,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if(!isExists(schema, objectName)) return obj; - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); if (isToSaveData()) { @@ -108,7 +108,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio String ddl = metaSequence.getSequence().getOptions().get("ddl").toString(); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); ddl = replaceNames(ddl, schema, objectName, stLog); @@ -122,7 +122,6 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "backup", "backupError").withParams(obj.getName()), e); } finally { stLog.close(); @@ -205,7 +204,7 @@ public boolean createSchema(StatementLogging stLog, String schema){ ResultSet rs = st.executeQuery("select count(*) cnt from all_users where USERNAME = '" + PREFIX + schema + "'"); rs.next(); if (rs.getInt("cnt") == 0) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), messageLevel); stLog.execute("create USER \"" + PREFIX + schema + "\"\r\n" + "IDENTIFIED BY \"" + PREFIX + schema + "\"\r\n" + "DEFAULT TABLESPACE \"SYSTEM\"\r\n" + @@ -220,7 +219,7 @@ public boolean createSchema(StatementLogging stLog, String schema){ return true; } catch (SQLException e) { - ConsoleWriter.println(lang.getValue("errors", "backup", "cannotCreateSchema").withParams(e.getLocalizedMessage())); + ConsoleWriter.println(lang.getValue("errors", "backup", "cannotCreateSchema").withParams(e.getLocalizedMessage()), messageLevel); return false; } diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreFunctionOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreFunctionOracle.java index 1050662..736d146 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreFunctionOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreFunctionOracle.java @@ -43,11 +43,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "function", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java index 14a067c..36c6b73 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestorePackageOracle.java @@ -48,13 +48,14 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "package", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreProcedureOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreProcedureOracle.java index 75dc7aa..16c04a0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreProcedureOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreProcedureOracle.java @@ -44,13 +44,14 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "procedure", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreRoleOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreRoleOracle.java index 0e3f317..4fbe8c9 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreRoleOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreRoleOracle.java @@ -63,11 +63,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "role", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSchemaOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSchemaOracle.java index f24f969..ae867ba 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSchemaOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSchemaOracle.java @@ -47,11 +47,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "schema", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSequenceOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSequenceOracle.java index b8cccd2..49f5b2b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSequenceOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreSequenceOracle.java @@ -85,11 +85,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "sequence", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java index 27c6e88..3041ad2 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java @@ -29,10 +29,7 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.core.GitMetaDataManager; -import ru.fusionsoft.dbgit.core.SchemaSynonym; +import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.data_table.BooleanData; import ru.fusionsoft.dbgit.data_table.DateData; import ru.fusionsoft.dbgit.data_table.ICellData; @@ -91,7 +88,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { MetaTable metaTable = new MetaTable(currentTableData.getTable()); metaTable.loadFromDB(currentTableData.getTable()); - ConsoleWriter.println("ids: " + metaTable.getIdColumns()); +// ConsoleWriter.println("ids: " + metaTable.getIdColumns()); if (rs != null) { while(rs.next()) { @@ -111,7 +108,10 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { return true; } else { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data", obj.getType().getValue() + )); } } @@ -145,7 +145,7 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat } if(!diffTableData.entriesOnlyOnLeft().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "inserting"), messageLevel); for(RowData rowData:diffTableData.entriesOnlyOnLeft().values()) { ArrayList fieldsList = new ArrayList(rowData.getData().keySet()); @@ -165,7 +165,7 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat } } - ConsoleWriter.detailsPrintLn(insertQuery); + ConsoleWriter.detailsPrintln(insertQuery, messageLevel); if (needSeparator) st.execute(insertQuery, "/"); else @@ -177,14 +177,16 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat } if(!diffTableData.entriesOnlyOnRight().isEmpty()) { boolean isSuccessful = true; - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); for(RowData rowData : diffTableData.entriesOnlyOnRight().values()) { Map primarykeys = getKeys(rowData); if (primarykeys.size() == 0) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.printlnRed(lang.getValue("errors", "restore", "pkNotFound").withParams(tblName)); +// ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + ConsoleWriter.printlnRed(lang.getValue("errors", "restore", "pkNotFound") + .withParams(tblName), messageLevel + ); isSuccessful = false; break; } @@ -197,20 +199,20 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat st.execute(deleteQuery); } - if (isSuccessful) ConsoleWriter.detailsPrintlnGreen("OK"); + if (isSuccessful) ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "meta", "ok"), messageLevel); } if(!diffTableData.entriesDiffering().isEmpty()) { boolean isSuccessful = true; - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "updating"), messageLevel); for (ValueDifference diffRowData:diffTableData.entriesDiffering().values()) { if (!diffRowData.leftValue().getHashRow().equals(diffRowData.rightValue().getHashRow())) { Map primarykeys = getKeys(diffRowData.leftValue()); if (primarykeys.size() == 0) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.printlnRed(lang.getValue("general", "restore", "pkNotFound").withParams(tblName),3); + ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail"), messageLevel); + ConsoleWriter.printlnRed(lang.getValue("general", "restore", "pkNotFound").withParams(tblName),messageLevel); isSuccessful = false; break; } @@ -247,12 +249,13 @@ private void restoreTableDataOracle(MetaTableData restoreTableData, MetaTableDat } } - if (isSuccessful) ConsoleWriter.detailsPrintlnGreen("OK"); + if (isSuccessful) ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "meta", "ok"), messageLevel); } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()), e); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()) + , e + ); } finally { st.close(); } @@ -270,8 +273,8 @@ private Map getKeys(RowData rowData) { primarykeys.put(entry.getKey(), entry.getValue().convertToString()); } } catch (Exception e) { - ConsoleWriter.printlnRed(lang.getValue("general", "restore", "pkNotFound").withParams(""),3); - ConsoleWriter.printlnRed(e.getMessage()); + ConsoleWriter.printlnRed(lang.getValue("general", "restore", "pkNotFound").withParams(""),messageLevel); + ConsoleWriter.detailsPrintlnRed(e.getMessage(), messageLevel); } } }); @@ -281,7 +284,7 @@ private Map getKeys(RowData rowData) { private void restoreTableConstraintOracle(MetaTable table) throws Exception { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), 1); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreConstr").withParams(table.getName()), messageLevel); IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -292,14 +295,12 @@ private void restoreTableConstraintOracle(MetaTable table) throws Exception { if(!constraint.getConstraintType().equalsIgnoreCase("p")) { String query = "alter table " + schema + "." + table.getTable().getName() + " add constraint "+ constraint.getName() + " " +constraint.getOptions().get("ddl").toString(); - ConsoleWriter.println(query); + ConsoleWriter.println(query, messageLevel); st.execute(query); } } ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(table.getTable().getName()), e); } finally { st.close(); @@ -307,7 +308,7 @@ private void restoreTableConstraintOracle(MetaTable table) throws Exception { } private void removeTableConstraintsOracle(MetaTable table) throws Exception { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), 1); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), messageLevel); IDBAdapter adapter = getAdapter(); StatementLogging st = new StatementLogging(adapter.getConnection(), adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); String schema = getPhisicalSchema(table.getTable().getSchema()); @@ -326,15 +327,15 @@ private void removeTableConstraintsOracle(MetaTable table) throws Exception { //String query = "if (OBJECT_ID(" + schema + "." + constraint.getName() + ")) then begin alter table " + schema + "." + table.getTable().getName() // + " drop constraint " + constraint.getName() + "; end"; - ConsoleWriter.println(dropQuery); + ConsoleWriter.println(dropQuery, messageLevel); st.execute(dropQuery, "/"); } } ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "cannotRestore").withParams(schema + "." + table.getTable().getName()), e); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "cannotRestore").withParams(schema + "." + table.getTable().getName()) + , e + ); } finally { st.close(); } diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java index ea432b1..f095fbc 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java @@ -1,430 +1,429 @@ -package ru.fusionsoft.dbgit.oracle; - -import java.sql.Connection; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.Comparator; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; - -import com.google.common.collect.MapDifference; -import com.google.common.collect.Maps; -import com.google.common.collect.MapDifference.ValueDifference; - -import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.core.SchemaSynonym; -import ru.fusionsoft.dbgit.dbobjects.DBConstraint; -import ru.fusionsoft.dbgit.dbobjects.DBIndex; -import ru.fusionsoft.dbgit.dbobjects.DBTable; -import ru.fusionsoft.dbgit.dbobjects.DBTableField; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaTable; -import ru.fusionsoft.dbgit.statement.StatementLogging; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -public class DBRestoreTableOracle extends DBRestoreAdapter { - - @Override - public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - if(Integer.valueOf(step).equals(0)) { - restoreTableOracle(obj); - return false; - } - /*if(Integer.valueOf(step).equals(1)) { - restoreTableFieldsOracle(obj); - return false; - }*/ - if(Integer.valueOf(step).equals(-21)) { - restoreTableIndexesOracle(obj); - return false; - } - if(Integer.valueOf(step).equals(-1)) { - restoreTableConstraintOracle(obj); - return false; - } - return true; - } - - public void restoreTableOracle(IMetaObject obj) throws Exception - { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { - if (obj instanceof MetaTable) { - - MetaTable restoreTable = (MetaTable)obj; - String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); - schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); - String tblName = schema+"."+restoreTable.getTable().getName(); - - Map tables = adapter.getTables(schema.toUpperCase()); - boolean exist = false; - if(!(tables.isEmpty() || tables == null)) { - for(DBTable table:tables.values()) { - if(restoreTable.getTable().getName().equalsIgnoreCase(table.getName())){ - exist = true; - - } - } - } - if(!exist){ - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "createTable"), 3); - String ddl = ""; - if (restoreTable.getTable().getOptions().get("ddl") != null) - ddl = restoreTable.getTable().getOptions().get("ddl").getData() - .replace("\"" + restoreTable.getTable().getSchema().toUpperCase() + "\"", "\"" + schema.toUpperCase() + "\""); - else { - DBTable table = restoreTable.getTable(); - - Comparator comparator = (o1, o2) -> o1.getOrder().compareTo(o2.getOrder()); - - ddl = "create table " + schema + "." + table.getName() + - " (" + restoreTable.getFields().values().stream() - .sorted(comparator) - .map(field -> "" + (adapter.isReservedWord(field.getName()) ? "\"" + field.getName() + "\" " : field.getName()) + " " + field.getTypeSQL()) - .collect(Collectors.joining(", ")) + ")"; - } - st.execute(ddl); - - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - } else { - //restore tabl fields - Map currentFileds = adapter.getTableFields(schema, restoreTable.getTable().getName().toLowerCase()); - MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),currentFileds); - - if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "addColumns"), 3); - - Comparator comparator = (o1, o2) -> o1.getOrder().compareTo(o2.getOrder()); - - List values = diffTableFields.entriesOnlyOnLeft().values().stream().collect(Collectors.toList()); - values.sort(comparator); - - for(DBTableField tblField : values) { - st.execute("alter table "+ tblName +" add " + tblField.getName() + " " + tblField.getTypeSQL()); - } - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - } - - if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "droppingColumns"), 3); - for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { - st.execute("alter table "+ tblName +" drop column "+ tblField.getName()); - } - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - } - - if(!diffTableFields.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "modifyColumns"), 3); - - for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { - if(!tblField.leftValue().getName().equals(tblField.rightValue().getName())) { - st.execute("alter table "+ tblName +" rename column "+ tblField.rightValue().getName() +" to "+ tblField.leftValue().getName()); - } - - if(!tblField.leftValue().getTypeUniversal().equals(tblField.rightValue().getTypeUniversal())) { - st.execute("alter table "+ tblName +" modify "+ tblField.leftValue().getName() +" "+ tblField.leftValue().getTypeSQL()); - } - } - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - } - } - - ResultSet rs = st.executeQuery("SELECT COUNT(cons.constraint_name) constraintscount \n" + - "FROM all_constraints cons \n" + - "WHERE upper(owner) = upper('" + schema + "') and upper(table_name) = upper('" + restoreTable.getTable().getName()+ "') and constraint_name not like 'SYS%' and cons.constraint_type = 'P'"); - rs.next(); - Integer constraintsCount = Integer.valueOf(rs.getString("constraintscount")); - if(constraintsCount.intValue()>0) { - removeTableConstraintsOracle(obj); - } - // set primary key - boolean flagPkCreated = false; - for(DBConstraint tableconst: restoreTable.getConstraints().values()) { - if(tableconst.getConstraintType().equals("p")) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 2); - - if (tableconst.getOptions().get("ddl").toString().toLowerCase().startsWith("alter table")) - st.execute(tableconst.getOptions().get("ddl").toString().replace(" " +tableconst.getSchema() + ".", " " + schema + ".")); - else if (tableconst.getOptions().get("ddl").toString().toLowerCase().startsWith("primary key")) - st.execute("alter table "+ tblName +" add constraint PK_"+ tableconst.getName() + tableconst.getOptions().get("ddl").toString()); - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - flagPkCreated = true; - break; - } - } - - if (!flagPkCreated) { - for(DBTableField field: restoreTable.getFields().values()) { - if (field.getIsPrimaryKey()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "addPk"), 2); - st.execute("alter table "+ tblName +" add constraint pk_" + restoreTable.getTable().getName() + "_" + field.getName() + " PRIMARY KEY (" + field.getName() + ")"); - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - break; - } - } - } - - - } - else - { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (SQLException e1) { - ConsoleWriter.detailsPrintlnRed(lang.getValue(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage())); - //throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage()); - } catch (Exception e) { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } - - public void restoreTableFieldsOracle(IMetaObject obj) throws Exception - { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { - if (obj instanceof MetaTable) { - MetaTable restoreTable = (MetaTable)obj; - String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); - schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); - String tblName = schema+"."+restoreTable.getTable().getName(); - Map tables = adapter.getTables(schema); - boolean exist = false; - if(!(tables.isEmpty() || tables == null)) { - for(DBTable table:tables.values()) { - if(restoreTable.getTable().getName().equals(table.getName())){ - exist = true; - } - } - } - if(!exist){ - st.execute(restoreTable.getTable().getOptions().get("ddl").getData()); - } - //restore tabl fields - Map currentFileds = adapter.getTableFields(schema, restoreTable.getTable().getName()); - MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),currentFileds); - - if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ - for(DBTableField tblField:diffTableFields.entriesOnlyOnLeft().values()) { - st.execute("alter table "+ tblName +" add " + tblField.getName() + " " + tblField.getTypeSQL()); - } - } - - if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { - for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { - st.execute("alter table "+ tblName +" drop column "+ tblField.getName()); - } - } - - if(!diffTableFields.entriesDiffering().isEmpty()) { - for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { - if(!tblField.leftValue().getName().equals(tblField.rightValue().getName())) { - st.execute("alter table "+ tblName +" rename column "+ tblField.rightValue().getName() +" to "+ tblField.leftValue().getName()); - } - - if(!tblField.leftValue().getTypeSQL().equals(tblField.rightValue().getTypeSQL())) { - st.execute("alter table "+ tblName +" modify "+ tblField.leftValue().getName() +" "+ tblField.leftValue().getTypeSQL()); - } - } - } - - ResultSet rs = st.executeQuery("SELECT COUNT(cons.constraint_name)\n" + - "FROM all_constraints cons \n" + - "WHERE upper(owner) = upper('" + schema + "') and upper(table_name) = upper('" + tblName+ "') and constraint_name not like 'SYS%' and cons.constraint_type = 'P'"); - rs.next(); - Integer constraintsCount = Integer.valueOf(rs.getString("constraintscount")); - if(constraintsCount.intValue()>0) { - removeTableConstraintsOracle(obj); - } - // set primary key - for(DBConstraint tableconst: restoreTable.getConstraints().values()) { - if(tableconst.getConstraintType().equals("p")) { - st.execute(restoreTable.getConstraints().get("constraintDef").getOptions().get("ddl").toString()); - //st.execute("alter table "+ tblName +" add constraint PK_"+ tableconst.getName() + " primary key ("+tableconst.getName() + ")"); - break; - } - } - } - else - { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (SQLException e1) { - ConsoleWriter.detailsPrintlnRed(lang.getValue(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage())); - //throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage()); - } catch (Exception e) { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } - - public void restoreTableIndexesOracle(IMetaObject obj) throws Exception - { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 3); - try { - if (obj instanceof MetaTable) { - MetaTable restoreTable = (MetaTable)obj; - String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); - schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); - Map tables = adapter.getTables(schema); - boolean exist = false; - if(!(tables.isEmpty() || tables == null)) { - for(DBTable table:tables.values()) { - if(restoreTable.getTable().getName().equals(table.getName())){ - exist = true; - Map currentIndexes = adapter.getIndexes(schema, table.getName()); - MapDifference diffInd = Maps.difference(restoreTable.getIndexes(), currentIndexes); - if(!diffInd.entriesOnlyOnLeft().isEmpty()) { - for(DBIndex ind:diffInd.entriesOnlyOnLeft().values()) { - ConsoleWriter.println(ind.getSql()); - if (ind.getSql().length() > 5 ) - st.execute(ind.getSql()); - } - } - if(!diffInd.entriesOnlyOnRight().isEmpty()) { - for(DBIndex ind:diffInd.entriesOnlyOnRight().values()) { - st.execute("drop index "+schema+"."+ind.getName()); - } - } - - //not fact, will check in future - } - } - } - if(!exist){ - for(DBIndex ind:restoreTable.getIndexes().values()) { - st.execute(ind.getSql()); - } - } - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - } - else - { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (SQLException e1) { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage()); - } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } - - public void restoreTableConstraintOracle(IMetaObject obj) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreConstr").withParams(obj.getName()), 3); - try { - if (obj instanceof MetaTable) { - MetaTable restoreTable = (MetaTable)obj; - String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); - schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); - for(DBConstraint constrs :restoreTable.getConstraints().values()) { - if(!constrs.getConstraintType().equalsIgnoreCase("P")) { - //String tblName = schema+"."+restoreTable.getTable().getName(); - - st.execute(constrs.getOptions().get("ddl").toString().replace(" " + constrs.getSchema() + ".", " " + schema + ".")); - } - } - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - } - else - { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (SQLException e1) { - ConsoleWriter.detailsPrintlnRed(lang.getValue(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage())); - //throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage()); - } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } - - public void removeTableConstraintsOracle(IMetaObject obj) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { - if (obj instanceof MetaTable) { - MetaTable table = (MetaTable)obj; - String schema = getPhisicalSchema(table.getTable().getSchema()); - schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); - Map constraints = table.getConstraints(); - for(DBConstraint constrs :constraints.values()) { - - String dropQuery = "declare cnt number;\r\n" + - "begin \r\n" + - "select count(*) into cnt from ALL_CONSTRAINTS where upper(CONSTRAINT_NAME) = upper('" + constrs.getName() + "') and upper(owner) = upper('" + schema + "');\r\n" + - " if (cnt > 0) \r\n" + - " then \r\n" + - " execute immediate('alter table " + schema + "." + table.getTable().getName() + " drop constraint " + constrs.getName() + "');\r\n" + - " end if;\r\n" + - "end;"; - - - st.execute(dropQuery, "/"); - } - //} - } - else - { - throw new ExceptionDBGitRestore("Error restore: Unable to remove TableConstraints."); - } - - } catch (SQLException e1) { - ConsoleWriter.detailsPrintlnRed(lang.getValue(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage())); - //throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage()); - } catch (Exception e) { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } - } - - /*public void removeIndexesOracle(IMetaObject obj) throws Exception { - - }*/ - - public void removeMetaObject(IMetaObject obj) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - - try { - - MetaTable tblMeta = (MetaTable)obj; - DBTable tbl = tblMeta.getTable(); - //String schema = getPhisicalSchema(tbl.getSchema()); - - st.execute("DROP TABLE " +tbl.getName()); - - // TODO Auto-generated method stub - } catch (SQLException e1) { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + "\n"+ e1.getLocalizedMessage()); - } catch (Exception e) { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } - -} +package ru.fusionsoft.dbgit.oracle; + +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import com.google.common.collect.MapDifference; +import com.google.common.collect.Maps; +import com.google.common.collect.MapDifference.ValueDifference; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.core.SchemaSynonym; +import ru.fusionsoft.dbgit.dbobjects.DBConstraint; +import ru.fusionsoft.dbgit.dbobjects.DBIndex; +import ru.fusionsoft.dbgit.dbobjects.DBTable; +import ru.fusionsoft.dbgit.dbobjects.DBTableField; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaTable; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +public class DBRestoreTableOracle extends DBRestoreAdapter { + + @Override + public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + if(Integer.valueOf(step).equals(0)) { + restoreTableOracle(obj); + return false; + } + /*if(Integer.valueOf(step).equals(1)) { + restoreTableFieldsOracle(obj); + return false; + }*/ + if(Integer.valueOf(step).equals(-21)) { + restoreTableIndexesOracle(obj); + return false; + } + if(Integer.valueOf(step).equals(-1)) { + restoreTableConstraintOracle(obj); + return false; + } + return true; + } + + public void restoreTableOracle(IMetaObject obj) throws Exception + { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + try { + if (obj instanceof MetaTable) { + + MetaTable restoreTable = (MetaTable)obj; + String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); + schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); + String tblName = schema+"."+restoreTable.getTable().getName(); + + Map tables = adapter.getTables(schema.toUpperCase()); + boolean exist = false; + if(!(tables.isEmpty() || tables == null)) { + for(DBTable table:tables.values()) { + if(restoreTable.getTable().getName().equalsIgnoreCase(table.getName())){ + exist = true; + + } + } + } + if(!exist){ + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "createTable"), messageLevel); + String ddl = ""; + if (restoreTable.getTable().getOptions().get("ddl") != null) + ddl = restoreTable.getTable().getOptions().get("ddl").getData() + .replace("\"" + restoreTable.getTable().getSchema().toUpperCase() + "\"", "\"" + schema.toUpperCase() + "\""); + else { + DBTable table = restoreTable.getTable(); + + Comparator comparator = Comparator.comparing(DBTableField::getOrder); + + ddl = "create table " + schema + "." + table.getName() + + " (" + restoreTable.getFields().values().stream() + .sorted(comparator) + .map(field -> "" + (adapter.isReservedWord(field.getName()) ? "\"" + field.getName() + "\" " : field.getName()) + " " + field.getTypeSQL()) + .collect(Collectors.joining(", ")) + ")"; + } + st.execute(ddl); + + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } else { + //restore tabl fields + Map currentFileds = adapter.getTableFields(schema, restoreTable.getTable().getName().toLowerCase()); + MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),currentFileds); + + if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "addColumns"), messageLevel); + + Comparator comparator = Comparator.comparing(DBTableField::getOrder); + + List values = diffTableFields.entriesOnlyOnLeft().values().stream().collect(Collectors.toList()); + values.sort(comparator); + + for(DBTableField tblField : values) { + st.execute("alter table "+ tblName +" add " + tblField.getName() + " " + tblField.getTypeSQL()); + } + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + + if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "droppingColumns"), messageLevel); + for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { + st.execute("alter table "+ tblName +" drop column "+ tblField.getName()); + } + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + + if(!diffTableFields.entriesDiffering().isEmpty()) { + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "modifyColumns"), messageLevel); + + for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { + if(!tblField.leftValue().getName().equals(tblField.rightValue().getName())) { + st.execute("alter table "+ tblName +" rename column "+ tblField.rightValue().getName() +" to "+ tblField.leftValue().getName()); + } + + if(!tblField.leftValue().getTypeUniversal().equals(tblField.rightValue().getTypeUniversal())) { + st.execute("alter table "+ tblName +" modify "+ tblField.leftValue().getName() +" "+ tblField.leftValue().getTypeSQL()); + } + } + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + } + + ResultSet rs = st.executeQuery("SELECT COUNT(cons.constraint_name) constraintscount \n" + + "FROM all_constraints cons \n" + + "WHERE upper(owner) = upper('" + schema + "') and upper(table_name) = upper('" + restoreTable.getTable().getName()+ "') and constraint_name not like 'SYS%' and cons.constraint_type = 'P'"); + rs.next(); + Integer constraintsCount = Integer.valueOf(rs.getString("constraintscount")); + if(constraintsCount.intValue()>0) { + removeTableConstraintsOracle(obj); + } + // set primary key + boolean flagPkCreated = false; + for(DBConstraint tableconst: restoreTable.getConstraints().values()) { + if(tableconst.getConstraintType().equals("p")) { + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "addPk"), messageLevel); + + if (tableconst.getOptions().get("ddl").toString().toLowerCase().startsWith("alter table")) + st.execute(tableconst.getOptions().get("ddl").toString().replace(" " +tableconst.getSchema() + ".", " " + schema + ".")); + else if (tableconst.getOptions().get("ddl").toString().toLowerCase().startsWith("primary key")) + st.execute("alter table "+ tblName +" add constraint PK_"+ tableconst.getName() + tableconst.getOptions().get("ddl").toString()); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + flagPkCreated = true; + break; + } + } + + if (!flagPkCreated) { + for(DBTableField field: restoreTable.getFields().values()) { + if (field.getIsPrimaryKey()) { + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "addPk"), messageLevel); + st.execute("alter table "+ tblName +" add constraint pk_" + restoreTable.getTable().getName() + "_" + field.getName() + " PRIMARY KEY (" + field.getName() + ")"); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + break; + } + } + } + + + } + else + { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); + } + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + st.close(); + } + } + + public void restoreTableFieldsOracle(IMetaObject obj) throws Exception + { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + try { + if (obj instanceof MetaTable) { + MetaTable restoreTable = (MetaTable)obj; + String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); + schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); + String tblName = schema+"."+restoreTable.getTable().getName(); + Map tables = adapter.getTables(schema); + boolean exist = false; + if(!(tables.isEmpty() || tables == null)) { + for(DBTable table:tables.values()) { + if(restoreTable.getTable().getName().equals(table.getName())){ + exist = true; + } + } + } + if(!exist){ + st.execute(restoreTable.getTable().getOptions().get("ddl").getData()); + } + //restore tabl fields + Map currentFileds = adapter.getTableFields(schema, restoreTable.getTable().getName()); + MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),currentFileds); + + if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ + for(DBTableField tblField:diffTableFields.entriesOnlyOnLeft().values()) { + st.execute("alter table "+ tblName +" add " + tblField.getName() + " " + tblField.getTypeSQL()); + } + } + + if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { + for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { + st.execute("alter table "+ tblName +" drop column "+ tblField.getName()); + } + } + + if(!diffTableFields.entriesDiffering().isEmpty()) { + for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { + if(!tblField.leftValue().getName().equals(tblField.rightValue().getName())) { + st.execute("alter table "+ tblName +" rename column "+ tblField.rightValue().getName() +" to "+ tblField.leftValue().getName()); + } + + if(!tblField.leftValue().getTypeSQL().equals(tblField.rightValue().getTypeSQL())) { + st.execute("alter table "+ tblName +" modify "+ tblField.leftValue().getName() +" "+ tblField.leftValue().getTypeSQL()); + } + } + } + + ResultSet rs = st.executeQuery("SELECT COUNT(cons.constraint_name)\n" + + "FROM all_constraints cons \n" + + "WHERE upper(owner) = upper('" + schema + "') and upper(table_name) = upper('" + tblName+ "') and constraint_name not like 'SYS%' and cons.constraint_type = 'P'"); + rs.next(); + Integer constraintsCount = Integer.valueOf(rs.getString("constraintscount")); + if(constraintsCount.intValue()>0) { + removeTableConstraintsOracle(obj); + } + // set primary key + for(DBConstraint tableconst: restoreTable.getConstraints().values()) { + if(tableconst.getConstraintType().equals("p")) { + st.execute(restoreTable.getConstraints().get("constraintDef").getOptions().get("ddl").toString()); + //st.execute("alter table "+ tblName +" add constraint PK_"+ tableconst.getName() + " primary key ("+tableconst.getName() + ")"); + break; + } + } + } + else + { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); + } + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + st.close(); + } + } + + public void restoreTableIndexesOracle(IMetaObject obj) throws Exception + { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), messageLevel); + try { + if (obj instanceof MetaTable) { + MetaTable restoreTable = (MetaTable)obj; + String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); + schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); + Map tables = adapter.getTables(schema); + boolean exist = false; + if(!(tables.isEmpty() || tables == null)) { + for(DBTable table:tables.values()) { + if(restoreTable.getTable().getName().equals(table.getName())){ + exist = true; + Map currentIndexes = adapter.getIndexes(schema, table.getName()); + MapDifference diffInd = Maps.difference(restoreTable.getIndexes(), currentIndexes); + if(!diffInd.entriesOnlyOnLeft().isEmpty()) { + for(DBIndex ind:diffInd.entriesOnlyOnLeft().values()) { +// ConsoleWriter.println(ind.getSql()); + if (ind.getSql().length() > 5 ) + st.execute(ind.getSql()); + } + } + if(!diffInd.entriesOnlyOnRight().isEmpty()) { + for(DBIndex ind:diffInd.entriesOnlyOnRight().values()) { + st.execute("drop index "+schema+"."+ind.getName()); + } + } + + //not fact, will check in future + } + } + } + if(!exist){ + for(DBIndex ind:restoreTable.getIndexes().values()) { + st.execute(ind.getSql()); + } + } + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + else + { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); + } + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError") + .withParams(obj.getName()) + , e + ); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + st.close(); + } + } + + public void restoreTableConstraintOracle(IMetaObject obj) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreConstr") + .withParams(obj.getName()) + , messageLevel + ); + try { + if (obj instanceof MetaTable) { + MetaTable restoreTable = (MetaTable)obj; + String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); + schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); + for(DBConstraint constrs :restoreTable.getConstraints().values()) { + if(!constrs.getConstraintType().equalsIgnoreCase("P")) { + //String tblName = schema+"."+restoreTable.getTable().getName(); + + st.execute(constrs.getOptions().get("ddl").toString().replace(" " + constrs.getSchema() + ".", " " + schema + ".")); + } + } + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + else + { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); + } + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + st.close(); + } + } + + public void removeTableConstraintsOracle(IMetaObject obj) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + try { + if (obj instanceof MetaTable) { + MetaTable table = (MetaTable)obj; + String schema = getPhisicalSchema(table.getTable().getSchema()); + schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); + Map constraints = table.getConstraints(); + for(DBConstraint constrs :constraints.values()) { + + String dropQuery = "declare cnt number;\r\n" + + "begin \r\n" + + "select count(*) into cnt from ALL_CONSTRAINTS where upper(CONSTRAINT_NAME) = upper('" + constrs.getName() + "') and upper(owner) = upper('" + schema + "');\r\n" + + " if (cnt > 0) \r\n" + + " then \r\n" + + " execute immediate('alter table " + schema + "." + table.getTable().getName() + " drop constraint " + constrs.getName() + "');\r\n" + + " end if;\r\n" + + "end;"; + + + st.execute(dropQuery, "/"); + } + //} + } + else + { + throw new ExceptionDBGitRestore("Error restore: Unable to remove TableConstraints."); + } + + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } + } + + /*public void removeIndexesOracle(IMetaObject obj) throws Exception { + + }*/ + + public void removeMetaObject(IMetaObject obj) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + + try { + + MetaTable tblMeta = (MetaTable)obj; + DBTable tbl = tblMeta.getTable(); + //String schema = getPhisicalSchema(tbl.getSchema()); + + st.execute("DROP TABLE " +tbl.getName()); + + // TODO Auto-generated method stub + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); + } finally { + st.close(); + } + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTriggerOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTriggerOracle.java index efa3fb6..35aa832 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTriggerOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTriggerOracle.java @@ -45,13 +45,14 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "trigger", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreViewOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreViewOracle.java index 61e80b9..0df3c02 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreViewOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreViewOracle.java @@ -47,11 +47,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "view", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDBAdapterRestoreOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDBAdapterRestoreOracle.java index d36af5c..23ed6b6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDBAdapterRestoreOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDBAdapterRestoreOracle.java @@ -40,7 +40,10 @@ public IDBAdapterRestoreMetaData getAdapterRestore(IDBGitMetaType tp, IDBAdapter if (!restoreAdapters.containsKey(tp.getValue())) { //return new DBRestoreMetaNotSupport(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "restore", "cannotRestore").withParams(tp.getValue())); + ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "restore", "cannotRestore") + .withParams(tp.getValue()) + , messageLevel + ); return null; } diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDbConvertAdapterOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDbConvertAdapterOracle.java index 2ff1b70..ce70254 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDbConvertAdapterOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/FactoryDbConvertAdapterOracle.java @@ -6,6 +6,7 @@ import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.meta.DBGitMetaType; import ru.fusionsoft.dbgit.oracle.converters.TableConverterOracle; @@ -27,7 +28,11 @@ public class FactoryDbConvertAdapterOracle implements IFactoryDBConvertAdapter { @Override public IDBConvertAdapter getConvertAdapter(String objectType) throws Exception { if (!converters.containsKey(objectType)) { - ConsoleWriter.println("Cannot convert " + objectType + "!"); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "convert", "cannotConvert") + .withParams(objectType) + , 1 + ); return null; } else return converters.get(objectType); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/converters/TableConverterOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/converters/TableConverterOracle.java index f423a9b..b194886 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/converters/TableConverterOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/converters/TableConverterOracle.java @@ -5,6 +5,7 @@ import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; @@ -25,9 +26,13 @@ public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) thr if (obj instanceof MetaTable) { MetaTable table = (MetaTable) obj; - - ConsoleWriter.println("Processing table " + table.getName()); - + + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingTable") + .withParams(table.getName()) + , messageLevel + ); + //types for (DBTableField field : table.getFields().values()) field.setTypeSQL(typeFromAnotherDB(objDbType, field)); @@ -54,14 +59,23 @@ public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) thr } private String indexFromPostgres(DBIndex index) { - ConsoleWriter.println("Converting table index " + index.getName() + " from postgresql to oracle..."); - + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingIndex") + .withParams(index.getName(), "postgresql", "oracle") + , messageLevel + ); + return ""; } private String constraintFromPostgres(MetaTable table, DBConstraint constraint) { - ConsoleWriter.println("Converting table constraint " + constraint.getName() + " from postgresql to oracle..."); - + + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingConstraint") + .withParams(constraint.getName(), "postgresql", "oracle") + , messageLevel + ); + String ddl = constraint.getOptions().get("ddl") .toString() .replace("ON UPDATE CASCADE", "") @@ -76,7 +90,13 @@ private String constraintFromPostgres(MetaTable table, DBConstraint constraint) } private String typeFromAnotherDB(DbType dbType, DBTableField field) { - ConsoleWriter.println("Converting table field " + field.getName() + " from " + dbType.toString().toLowerCase() + " to oracle..."); + + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingField") + .withParams(field.getName(), dbType.toString(), "oracle") + , messageLevel + ); + String result = ""; switch (field.getTypeUniversal()) { case STRING: diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index 7203031..dd0b95e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -457,8 +457,9 @@ public Map getIndexes(String schema, String nameTable) { return indexes; }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "indexes").toString()); - throw new ExceptionDBGitRunTime(e.getMessage()); + String msg = lang.getValue("errors", "adapter", "indexes").toString(); + logger.error(msg); + throw new ExceptionDBGitRunTime(msg, e); } } @@ -873,9 +874,9 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port data.setResultSet(rs); return data; } catch(Exception e) { - ConsoleWriter.println("err: " + e.getLocalizedMessage()); - - logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); + ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); + ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); + logger.error(DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(), e); try { if (tryNumber <= DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000))) { @@ -884,7 +885,11 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port } catch (InterruptedException e1) { throw new ExceptionDBGitRunTime(e1.getMessage()); } - ConsoleWriter.println("Error while getting portion of data, try " + tryNumber); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "dataTable", "loadPortionError") + .withParams(String.valueOf(tryNumber)) + , messageLevel + ); getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); } } catch (Exception e1) { diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java index 1f0048c..a90af29 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java @@ -39,7 +39,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio createSchema(stLog, schema); } - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); //dropIfExists(isSaveToSchema() ? PREFIX + schema : schema, // isSaveToSchema() ? objectName : PREFIX + objectName, stLog); @@ -77,7 +77,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio if (isSaveToSchema()) { createSchema(stLog, schema); } - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), messageLevel); StringBuilder tableDdlSb = new StringBuilder(MessageFormat.format( "create table {0} as (select * from {1}.{2} where 1={3}) {4};\n alter table {0} owner to {5};\n" @@ -165,7 +165,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio String sequenceName = getFullDbName(schema, objectName); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(objectName, getFullDbName(schema, objectName)), messageLevel); String ddl = "create sequence " + sequenceName + "\n" + (metaSequence.getSequence().getOptions().get("cycle_option").toString().equals("YES") ? "CYCLE\n" : "") @@ -190,11 +190,11 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio } } catch (SQLException e1) { - throw new ExceptionDBGit(lang.getValue("errors", "backup", "backupError"). - withParams(obj.getName() + ": " + e1.getLocalizedMessage())); + throw new ExceptionDBGit( + lang.getValue("errors", "backup", "backupError").withParams(obj.getName()) + , e1 + ); } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - connection.rollback(); throw new ExceptionDBGitRestore(lang.getValue("errors", "backup", "backupError").withParams(obj.getName()), e); } finally { stLog.close(); @@ -299,7 +299,7 @@ public boolean createSchema(StatementLogging stLog, String schema) { rs.next(); if (rs.getInt("cnt") == 0) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "creatingSchema").withParams(PREFIX + schema), messageLevel); stLog.execute("create schema " + adapter.escapeNameIfNeeded(PREFIX + schema)); } @@ -309,7 +309,10 @@ public boolean createSchema(StatementLogging stLog, String schema) { return true; } catch (SQLException e) { - ConsoleWriter.println(lang.getValue("errors", "backup", "cannotCreateSchema").withParams(e.getLocalizedMessage())); + ConsoleWriter.println(lang.getValue("errors", "backup", "cannotCreateSchema") + .withParams(e.getLocalizedMessage()) + , messageLevel + ); return false; } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java index 3ba29aa..c086d19 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java @@ -1,104 +1,103 @@ -package ru.fusionsoft.dbgit.postgres; - -import java.sql.Connection; -import java.text.MessageFormat; -import java.util.Map; - -import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.dbobjects.DBFunction; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaFunction; -import ru.fusionsoft.dbgit.statement.StatementLogging; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import ru.fusionsoft.dbgit.utils.StringProperties; - -public class DBRestoreFunctionPostgres extends DBRestoreAdapter { - - @Override - public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { - if (obj instanceof MetaFunction) { - - MetaFunction restoreFunction = (MetaFunction)obj; - String restoreFunctionName = restoreFunction.getSqlObject().getName(); - Map functions = adapter.getFunctions(restoreFunction.getSqlObject().getSchema()); - boolean exist = false; - if(!(functions.isEmpty() || functions == null)) { - for(DBFunction fnc:functions.values()) { - if(restoreFunctionName.equals(fnc.getName())){ - exist = true; - - //if codes differ - if( !restoreFunction.getSqlObject().getSql() - .replace(" ", "") - .equals(fnc.getSql().replace(" ", "")) - ) { - st.execute(restoreFunction.getSqlObject().getSql()); - } - - //if owners differ - if(!restoreFunction.getSqlObject().getOwner().equals(fnc.getOwner())) { - StringProperties restoreProcArgs = restoreFunction.getSqlObject().getOptions().get("arguments"); - String args = restoreProcArgs != null ? restoreProcArgs.getData().replaceAll("(\\w+ \\w+) (DEFAULT [^\\,\\n]+)(\\,|\\b)", "$1") : ""; - - st.execute(MessageFormat.format("ALTER FUNCTION {0}.{1}({2}) OWNER TO \"{3}\"" - , restoreFunction.getUnderlyingDbObject().getSchema() - , adapter.escapeNameIfNeeded(restoreFunctionName) - , args - , restoreFunction.getSqlObject().getOwner()) - ); - } - //TODO Восстановление привилегий - } - } - } - if(!exist){ - st.execute(restoreFunction.getSqlObject().getSql()); - //TODO Восстановление привилегий - } - } - else - { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.detailsPrintlnRed(e.getLocalizedMessage()); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - st.close(); - } - return true; - } - - @Override - public void removeMetaObject(IMetaObject obj) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - - try { - if(! (obj instanceof MetaFunction)) throw new ExceptionDBGit("Wrong IMetaObject type, expected: fnc, was: " + obj.getType().getValue()); - MetaFunction fncMeta = (MetaFunction) obj; - DBFunction fnc = (DBFunction) fncMeta.getSqlObject(); - if (fnc == null) return; - - String schema = getPhisicalSchema(fnc.getSchema()); - st.execute("DROP FUNCTION "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(fnc.getName())); - } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } - -} +package ru.fusionsoft.dbgit.postgres; + +import java.sql.Connection; +import java.text.MessageFormat; +import java.util.Map; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBFunction; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaFunction; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.utils.StringProperties; + +public class DBRestoreFunctionPostgres extends DBRestoreAdapter { + + @Override + public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + try { + if (obj instanceof MetaFunction) { + + MetaFunction restoreFunction = (MetaFunction)obj; + String restoreFunctionName = restoreFunction.getSqlObject().getName(); + Map functions = adapter.getFunctions(restoreFunction.getSqlObject().getSchema()); + boolean exist = false; + if(!(functions.isEmpty() || functions == null)) { + for(DBFunction fnc:functions.values()) { + if(restoreFunctionName.equals(fnc.getName())){ + exist = true; + + //if codes differ + if( !restoreFunction.getSqlObject().getSql() + .replace(" ", "") + .equals(fnc.getSql().replace(" ", "")) + ) { + st.execute(restoreFunction.getSqlObject().getSql()); + } + + //if owners differ + if(!restoreFunction.getSqlObject().getOwner().equals(fnc.getOwner())) { + StringProperties restoreProcArgs = restoreFunction.getSqlObject().getOptions().get("arguments"); + String args = restoreProcArgs != null ? restoreProcArgs.getData().replaceAll("(\\w+ \\w+) (DEFAULT [^\\,\\n]+)(\\,|\\b)", "$1") : ""; + + st.execute(MessageFormat.format("ALTER FUNCTION {0}.{1}({2}) OWNER TO \"{3}\"" + , restoreFunction.getUnderlyingDbObject().getSchema() + , adapter.escapeNameIfNeeded(restoreFunctionName) + , args + , restoreFunction.getSqlObject().getOwner()) + ); + } + //TODO Восстановление привилегий + } + } + } + if(!exist){ + st.execute(restoreFunction.getSqlObject().getSql()); + //TODO Восстановление привилегий + } + } + else + { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "function", obj.getType().getValue() + )); + } + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + st.close(); + } + return true; + } + + @Override + public void removeMetaObject(IMetaObject obj) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + + try { + if(! (obj instanceof MetaFunction)) throw new ExceptionDBGit("Wrong IMetaObject type, expected: fnc, was: " + obj.getType().getValue()); + MetaFunction fncMeta = (MetaFunction) obj; + DBFunction fnc = (DBFunction) fncMeta.getSqlObject(); + if (fnc == null) return; + + String schema = getPhisicalSchema(fnc.getSchema()); + st.execute("DROP FUNCTION "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(fnc.getName())); + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); + } finally { + st.close(); + } + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java index 982472c..a01e982 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java @@ -65,12 +65,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "procedure", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.detailsPrintlnRed(e.getLocalizedMessage()); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); @@ -95,7 +95,6 @@ public void removeMetaObject(IMetaObject obj) throws Exception String schema = getPhisicalSchema(prc.getSchema()); st.execute("DROP PROCEDURE "+schema+"."+adapter.escapeNameIfNeeded(prc.getName())); } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreRolePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreRolePostgres.java index 43f7e59..4f7310d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreRolePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreRolePostgres.java @@ -192,11 +192,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "role", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java index d3db7e1..9b2a99d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java @@ -45,11 +45,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "schema", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java index da3e59e..f3146be 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java @@ -101,11 +101,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "sequence", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { @@ -130,7 +131,6 @@ public void removeMetaObject(IMetaObject obj) throws Exception { st.execute("DROP SEQUENCE IF EXISTS "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(seq.getName())); } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index b6d878a..3ecf0dd 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -15,10 +15,7 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.core.GitMetaDataManager; -import ru.fusionsoft.dbgit.core.SchemaSynonym; +import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.data_table.BooleanData; import ru.fusionsoft.dbgit.data_table.DateData; import ru.fusionsoft.dbgit.data_table.ICellData; @@ -114,26 +111,36 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - //TODO WTF???? - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - //return true; + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data cached", obj.getType().getValue() + )); } } else { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data", obj.getType().getValue() + )); } } public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ List fieldsList = restoreTableData.getFields(); if(fieldsList.size() == 0 ) { - ConsoleWriter.detailsPrintlnRed("Empty fieldList, maybe empty csv"); + ConsoleWriter.printlnRed(DBGitLang.getInstance() + .getValue("errors", "restore", "emptyFieldsList") + , 1 + ); ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); return; } if (restoreTableData.getmapRows() == null) { - ConsoleWriter.detailsPrintlnRed("MapRows is null, maybe empty csv"); + ConsoleWriter.printlnRed(DBGitLang.getInstance() + .getValue("errors", "restore", "emptyRowsList") + , 1 + ); ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); return; } @@ -156,7 +163,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa //DELETE if (!diffTableData.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "deleting"), 2); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); StringBuilder deleteQuery = new StringBuilder(); for (RowData rowData : diffTableData.entriesOnlyOnRight().values()) { @@ -191,7 +198,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa //UPDATE if (!diffTableData.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "updating"), 2); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "updating"), messageLevel); String updateQuery = ""; Map primarykeys = new HashMap(); @@ -229,7 +236,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa + "WHERE (" + keyFieldsJoiner.toString() + ") = (" + keyValuesJoiner.toString() + ");\n"; - ConsoleWriter.detailsPrintLn(updateQuery); + ConsoleWriter.detailsPrintln(updateQuery, messageLevel); st.execute(updateQuery); updateQuery = ""; } @@ -239,14 +246,14 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); if (updateQuery.length() > 1) { - ConsoleWriter.println(updateQuery); + ConsoleWriter.println(updateQuery, messageLevel); st.execute(updateQuery); } } //INSERT if (!diffTableData.entriesOnlyOnLeft().isEmpty()) { - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "inserting"), 2); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "inserting"), messageLevel); for (RowData rowData : diffTableData.entriesOnlyOnLeft().values()) { String insertQuery = MessageFormat.format("INSERT INTO {0}{1}{2};\n" @@ -254,15 +261,16 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa , valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) ); - ConsoleWriter.detailsPrintLn(insertQuery); + ConsoleWriter.detailsPrintln(insertQuery, messageLevel); st.execute(insertQuery); } ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()), e); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()) + , e + ); } } @@ -415,9 +423,10 @@ public void restoreTableConstraintPostgres(MetaTable table) throws Exception { } } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(schema + "." + table.getTable().getName()), e); +// ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(schema + "." + table.getTable().getName()) + , e + ); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); @@ -432,7 +441,7 @@ public void removeTableConstraintsPostgres(MetaTable table) throws Exception { String schema = getPhisicalSchema(table.getTable().getSchema()); schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema + "." +table.getTable().getName(); - ConsoleWriter.detailsPrint(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), 1); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), messageLevel); try { ResultSet rs = stCnt.executeQuery("SELECT *\r\n" + " FROM pg_catalog.pg_constraint con\r\n" + @@ -463,8 +472,6 @@ public void removeTableConstraintsPostgres(MetaTable table) throws Exception { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "cannotRestore").withParams(schema + "." + table.getTable().getName()), e); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index e5ba8dd..f0a4aa6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -71,7 +71,6 @@ public void removeMetaObject(IMetaObject obj) throws Exception { freeTableSequences(tbl, connect, st); st.execute("DROP TABLE "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(tbl.getName())); } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); } finally { st.close(); @@ -102,7 +101,7 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception { } else { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "createTable"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "createTable"), messageLevel); createTable(st, restoreTable); ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); @@ -115,10 +114,12 @@ public void restoreTablePostgres(IMetaObject obj) throws Exception { } else { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { st.close(); @@ -128,7 +129,7 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreIndex").withParams(obj.getName()), messageLevel); try { if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable)obj; @@ -179,15 +180,15 @@ public void restoreTableIndexesPostgres(IMetaObject obj) throws Exception { } } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { -// ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); } } @@ -197,7 +198,7 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); try { if (obj instanceof MetaTable) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "restoreTableConstraints").withParams(obj.getName()), 2); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "restoreTableConstraints").withParams(obj.getName()), messageLevel); MetaTable restoreTable = (MetaTable)obj; MetaTable existingTable = new MetaTable(restoreTable.getTable()); existingTable.loadFromDB(); @@ -234,8 +235,10 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); @@ -264,7 +267,7 @@ private void restoreTableFields(MetaTable restoreTable, MetaTable existingTable, MapDifference diffTableFields = Maps.difference(restoreTable.getFields(),existingTable.getFields()); if(!diffTableFields.entriesOnlyOnLeft().isEmpty()){ - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "addColumns"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "addColumns"), messageLevel); List fields = diffTableFields.entriesOnlyOnLeft().values().stream() .sorted(Comparator.comparing(DBTableField::getOrder)) @@ -278,7 +281,7 @@ private void restoreTableFields(MetaTable restoreTable, MetaTable existingTable, } if(!diffTableFields.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "droppingColumns"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "droppingColumns"), messageLevel); for(DBTableField tblField:diffTableFields.entriesOnlyOnRight().values()) { lastField = tblField.getName(); dropColumn(tblSam, tblField, st); @@ -287,7 +290,7 @@ private void restoreTableFields(MetaTable restoreTable, MetaTable existingTable, } if(!diffTableFields.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "modifyColumns"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "modifyColumns"), messageLevel); for(ValueDifference tblField:diffTableFields.entriesDiffering().values()) { lastField = tblField.leftValue().getName(); @@ -599,7 +602,10 @@ private void removeTableIndexesPostgres(IMetaObject obj) throws Exception { } } else { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); @@ -625,11 +631,16 @@ private void removeTableConstraintsPostgres(IMetaObject obj) throws Exception { } } else { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()) + , e + ); + } } } /*public void removeIndexesPostgres(IMetaObject obj) throws Exception { diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java index 081ceaa..9874a35 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java @@ -67,11 +67,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "tablespace", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java index 008163f..cf2be3d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java @@ -1,99 +1,99 @@ -package ru.fusionsoft.dbgit.postgres; - -import java.sql.Connection; -import java.util.Map; - -import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.dbobjects.DBTrigger; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaTrigger; -import ru.fusionsoft.dbgit.statement.StatementLogging; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -public class DBRestoreTriggerPostgres extends DBRestoreAdapter { - - - @Override - public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { - if (obj instanceof MetaTrigger) { - MetaTrigger restoreTrigger = (MetaTrigger)obj; - Map trgs = adapter.getTriggers(restoreTrigger.getSqlObject().getSchema()); - boolean exist = false; - if(!(trgs.isEmpty() || trgs == null)) { - for(DBTrigger trg:trgs.values()) { - if(restoreTrigger.getSqlObject().getName().equals(trg.getName())){ - exist = true; - if(!restoreTrigger.getSqlObject().getSql().equals(trg.getSql())) { - String query = "DROP TRIGGER IF EXISTS "+restoreTrigger.getSqlObject().getName()+" ON "+restoreTrigger.getSqlObject().getOptions().get("trigger_table")+";\n"; - query+=restoreTrigger.getSqlObject().getSql()+";"; - st.execute(query); - } - //TODO Восстановление привилегий - } - } - } - if(!exist){ - st.execute(restoreTrigger.getSqlObject().getSql()); - //TODO Восстановление привилегий - } - } - else - { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); - } - - - - - } - catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - st.close(); - } - - - - - - - - - - return true; - } - - @Override - public void removeMetaObject(IMetaObject obj) throws Exception { - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - - try { - if(! (obj instanceof MetaTrigger)) throw new ExceptionDBGit("Wrong IMetaObject type, expected: trg, was: " + obj.getType().getValue()); - MetaTrigger trgMeta = (MetaTrigger) obj; - DBTrigger trg = (DBTrigger) trgMeta.getSqlObject(); - if (trg == null) return; - - String schema = getPhisicalSchema(trg.getSchema()); - st.execute("DROP FUNCTION IF EXISTS "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(trg.getName())); - - } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); - } finally { - st.close(); - } - } - -} +package ru.fusionsoft.dbgit.postgres; + +import java.sql.Connection; +import java.util.Map; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBTrigger; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaTrigger; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +public class DBRestoreTriggerPostgres extends DBRestoreAdapter { + + + @Override + public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + try { + if (obj instanceof MetaTrigger) { + MetaTrigger restoreTrigger = (MetaTrigger)obj; + Map trgs = adapter.getTriggers(restoreTrigger.getSqlObject().getSchema()); + boolean exist = false; + if(!(trgs.isEmpty() || trgs == null)) { + for(DBTrigger trg:trgs.values()) { + if(restoreTrigger.getSqlObject().getName().equals(trg.getName())){ + exist = true; + if(!restoreTrigger.getSqlObject().getSql().equals(trg.getSql())) { + String query = "DROP TRIGGER IF EXISTS "+restoreTrigger.getSqlObject().getName()+" ON "+restoreTrigger.getSqlObject().getOptions().get("trigger_table")+";\n"; + query+=restoreTrigger.getSqlObject().getSql()+";"; + st.execute(query); + } + //TODO Восстановление привилегий + } + } + } + if(!exist){ + st.execute(restoreTrigger.getSqlObject().getSql()); + //TODO Восстановление привилегий + } + } + else + { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "trigger", obj.getType().getValue() + )); + } + + + + + } + catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + st.close(); + } + + + + + + + + + + return true; + } + + @Override + public void removeMetaObject(IMetaObject obj) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); + + try { + if(! (obj instanceof MetaTrigger)) throw new ExceptionDBGit("Wrong IMetaObject type, expected: trg, was: " + obj.getType().getValue()); + MetaTrigger trgMeta = (MetaTrigger) obj; + DBTrigger trg = (DBTrigger) trgMeta.getSqlObject(); + if (trg == null) return; + + String schema = getPhisicalSchema(trg.getSchema()); + st.execute("DROP FUNCTION IF EXISTS "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(trg.getName())); + + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); + } finally { + st.close(); + } + } + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUserPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUserPostgres.java index b36b20e..7f1844a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUserPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUserPostgres.java @@ -24,11 +24,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "user", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java index 49a30c9..3d89b49 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java @@ -49,12 +49,16 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } else { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName())); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "view", obj.getType().getValue() + )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError") + .withParams(obj.getName()) + , e + ); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); st.close(); @@ -77,7 +81,7 @@ public void removeMetaObject(IMetaObject obj) throws Exception { String schema = getPhisicalSchema(vw.getSchema()); st.execute("DROP VIEW "+adapter.escapeNameIfNeeded(schema)+"."+adapter.escapeNameIfNeeded(vw.getName())); } catch (Exception e) { - ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage())); + ConsoleWriter.println(lang.getValue("errors", "restore", "objectRestoreError").withParams(e.getLocalizedMessage()),0); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRemoveError").withParams(obj.getName()), e); } finally { st.close(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDBAdapterRestorePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDBAdapterRestorePostgres.java index bb4e8c3..a9e8f3f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDBAdapterRestorePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDBAdapterRestorePostgres.java @@ -44,7 +44,7 @@ public class FactoryDBAdapterRestorePostgres implements IFactoryDBAdapterRestote public IDBAdapterRestoreMetaData getAdapterRestore(IDBGitMetaType tp, IDBAdapter adapter) { if (!restoreAdapters.containsKey(tp.getValue())) { //return new DBRestoreMetaNotSupport(); - ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "restore", "cannotRestore").withParams(tp.getValue())); + ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "restore", "cannotRestore").withParams(tp.getValue()), messageLevel); return null; } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDbConvertAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDbConvertAdapterPostgres.java index b8be656..08bdc62 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDbConvertAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDbConvertAdapterPostgres.java @@ -6,6 +6,7 @@ import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.meta.DBGitMetaType; import ru.fusionsoft.dbgit.oracle.converters.TableConverterOracle; @@ -34,7 +35,11 @@ public class FactoryDbConvertAdapterPostgres implements IFactoryDBConvertAdapter @Override public IDBConvertAdapter getConvertAdapter(String objectType) throws Exception { if (!converters.containsKey(objectType)) { - ConsoleWriter.detailsPrintlnRed("DBAdapterPostgres cannot convert " + objectType + "!"); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "convert", "cannotConvert") + .withParams(objectType) + , 1 + ); return null; } else return converters.get(objectType); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/converters/TableConverterPostgresql.java b/src/main/java/ru/fusionsoft/dbgit/postgres/converters/TableConverterPostgresql.java index 47c841d..9bdfd61 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/converters/TableConverterPostgresql.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/converters/TableConverterPostgresql.java @@ -5,6 +5,7 @@ import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; @@ -25,9 +26,12 @@ public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) thr if (obj instanceof MetaTable) { MetaTable table = (MetaTable) obj; - - ConsoleWriter.println("Processing table " + table.getName()); - + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "processingTable") + .withParams(table.getName()) + , messageLevel + ); + //types for (DBTableField field : table.getFields().values()) field.setTypeSQL(typeFromAnotherDB(objDbType, field)); @@ -54,26 +58,38 @@ public IMetaObject convert(DbType dbType, String dbVersion, IMetaObject obj) thr } private String indexFromOracle(DBIndex index) { - ConsoleWriter.println("Converting table index " + index.getName() + " from oracle to postgresql..."); - + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingIndex") + .withParams(index.getName(), "oracle", "postgresql") + , messageLevel + ); + return ""; } private String constraintFromOracle(DBConstraint constraint) { - ConsoleWriter.println("Converting table constraint " + constraint.getName() + " from oracle to postgresql..."); - - Pattern patternConstraint = Pattern.compile("(?<=" + constraint.getName() + ")(.*?)(?=\\))", Pattern.MULTILINE); - Matcher matcher = patternConstraint.matcher(constraint.getSql()); - - if (matcher.find()) { - return matcher.group().replace("\"", "") + ")"; - } else { - return ""; - } + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingConstraint") + .withParams(constraint.getName(), "oracle", "postgresql") + , messageLevel + ); + + Pattern patternConstraint = Pattern.compile("(?<=" + constraint.getName() + ")(.*?)(?=\\))", Pattern.MULTILINE); + Matcher matcher = patternConstraint.matcher(constraint.getSql()); + + if (matcher.find()) { + return matcher.group().replace("\"", "") + ")"; + } else { + return ""; + } } private String typeFromAnotherDB(DbType dbType, DBTableField field) { - ConsoleWriter.println("Converting table field " + field.getName() + " from " + dbType.toString().toLowerCase() + " to postgresql..."); + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "convert", "convertingField") + .withParams(field.getName(), dbType.toString(), "postgresql") + , messageLevel + ); String result = ""; switch (field.getTypeUniversal()) { case STRING: diff --git a/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java b/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java index 2e03955..798b647 100644 --- a/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java +++ b/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java @@ -1,177 +1,120 @@ -package ru.fusionsoft.dbgit.utils; - -import org.apache.commons.lang3.StringUtils; -import org.slf4j.Logger; - -import com.diogonunes.jcdp.color.ColoredPrinter; -import com.diogonunes.jcdp.color.api.Ansi.Attribute; -import com.diogonunes.jcdp.color.api.Ansi.BColor; -import com.diogonunes.jcdp.color.api.Ansi.FColor; - -public class ConsoleWriter { - private static Logger logger = LoggerUtil.getLogger(ConsoleWriter.class); - private static ColoredPrinter cp = new ColoredPrinter.Builder(1, false).build(); - private static boolean showDetailedLog = false; - - - public static void detailsPrintLn(Object msg) { - if (showDetailedLog) - println(msg.toString()); - } - - public static void detailsPrintColor(Object msg, int level, FColor color) { - if (showDetailedLog) - printColor(msg.toString(), color, level); - } - public static void detailsPrintLnColor(Object msg, int level, FColor color) { - if (showDetailedLog) - printlnColor(msg.toString(), color, level); - } - - public static void detailsPrint(Object msg, int level) { - if (showDetailedLog) - print(msg.toString(), level); - } - - - public static void detailsPrintlnRed(Object msg) { - if (showDetailedLog) - printlnColor(msg.toString(), FColor.RED, 0); - } - - public static void printlnGreen(Object msg, int level) { - printlnColor(msg.toString(), FColor.GREEN, level); - } - - public static void printlnGreen(Object msg) { - printlnColor(msg.toString(), FColor.GREEN, 0); - } - - public static void printlnRed(Object msg) { - printlnColor(msg.toString(), FColor.RED, 0); - } - - public static void printlnRed(Object msg, int level) { - printlnColor(msg.toString(), FColor.RED, level); - } - - public static void detailsPrintLn(String msg) { - if (showDetailedLog) - println(msg); - } - - public static void detailsPrintLn(String msg, int level) { - if (showDetailedLog) - println(msg, level); - } - - public static void detailsPrintLn(Object msg, int level) { - if (showDetailedLog) - println(msg.toString(), level); - } - - public static void detailsPrint(String msg, int level) { - if (showDetailedLog) - print(msg, level); - } - - public static void detailsPrintGreen(Object msg) { - if (showDetailedLog) - printColor(msg.toString(), FColor.GREEN, 0); - } - - public static void detailsPrintlnGreen(String msg) { - if (showDetailedLog) - printlnColor(msg, FColor.GREEN, 0); - } - - public static void detailsPrintlnRed(String msg) { - if (showDetailedLog) - printlnColor(msg, FColor.RED, 0); - } - - public static void printlnGreen(String msg) { - printlnColor(msg, FColor.GREEN, 0); - } - - public static void printlnRed(String msg) { - printlnColor(msg, FColor.RED, 0); - } - - public static void printlnColor(String msg, FColor color, Integer level) { - String tab = StringUtils.leftPad("", 4*level, " "); - /* - System.out.println(tab + msg); - if (1==1) return ; - */ - - cp.print("\n"+tab+msg, Attribute.NONE, color, BColor.BLACK); - cp.clear(); - //logger.info(msg); - } - - public static void printColor(String msg, FColor color, Integer level) { - String tab = StringUtils.leftPad("", 4*level, " "); - /* - System.out.println(tab + msg); - if (1==1) return ; - */ - cp.print(tab+msg, Attribute.NONE, color, BColor.BLACK); - cp.clear(); - //logger.info(msg); - } - - public static void println(Object msg) { - println(msg.toString(), 0); - } - - public static void println(String msg) { - println(msg, 0); - } - - public static void println(String msg, Integer level) { - String tab = StringUtils.leftPad("", 4*level, " "); - /* - System.out.println(tab + msg); - if (1==1) return ; - */ - printWhite("\n"+tab+msg); - cp.clear(); - //logger.info(msg); - } - - public static void println(Object msg, Integer level) { - println(msg.toString(), level); - } - - public static void print(String msg, Integer level) { - String tab = StringUtils.leftPad("", 4*level, " "); - /* - System.out.println(tab + msg); - if (1==1) return ; - */ - printWhite(tab+msg); - //logger.info(msg); - } - public static void print(Object msg, Integer level) { - print(msg.toString(), level); - } - public static void print(String msg) { - print(msg, 0); - } - public static void print(Object msg) { - print(msg.toString()); - } - - public static void setDetailedLog(boolean toShowLog) { - showDetailedLog = toShowLog; - } - - public static boolean getDetailedLog() { - return showDetailedLog; - } - public static void printWhite(String message){ - cp.print(message, Attribute.NONE, FColor.WHITE, BColor.BLACK); - cp.clear(); - } -} +package ru.fusionsoft.dbgit.utils; + +import org.apache.commons.lang3.StringUtils; +import org.slf4j.Logger; + +import com.diogonunes.jcdp.color.ColoredPrinter; +import com.diogonunes.jcdp.color.api.Ansi.Attribute; +import com.diogonunes.jcdp.color.api.Ansi.BColor; +import com.diogonunes.jcdp.color.api.Ansi.FColor; + +import java.text.MessageFormat; + +public class ConsoleWriter { + private static Logger logger = LoggerUtil.getLogger(ConsoleWriter.class); + private static ColoredPrinter cp = new ColoredPrinter.Builder(1, false).build(); + private static boolean showDetailedLog = false; + + + public static void print(Object message, FColor color, int level, boolean newLine, boolean onlyDetailed){ + if(onlyDetailed && !showDetailedLog) return; + + String tab = StringUtils.leftPad("", 4*level, " "); + String msg = MessageFormat.format("{0}{1}{2}", + newLine ? "\n" : "", + tab, + message.toString() + ); + + cp.print(msg, Attribute.NONE, color, BColor.BLACK); + cp.clear(); + + } + + public static void setDetailedLog(boolean toShowLog) { + showDetailedLog = toShowLog; + } + public static boolean getDetailedLog() { + return showDetailedLog; + } + + // Just print + // With no color, with color and with hardcoded colors + // - no levels cause them mean nothing without a newline + + public static void print(Object msg){ + print(msg, FColor.WHITE, 0, false, false); + } + + public static void printColor(Object msg, FColor color) { + print(msg, color, 0, false, false); + } + + public static void printGreen(Object msg) { + print(msg, FColor.GREEN, 0, false, false); + } + + public static void printRed(Object msg) { + print(msg, FColor.RED, 0, false, false); + } + + // Print with a newline + // With no color, with color and with hardcoded colors + // - with explicit level + + public static void printLineBreak(){println("", 0);} + + public static void println(Object msg, Integer level) { + print(msg, FColor.WHITE, level, true, false); + } + + public static void printlnColor(Object msg, FColor color, Integer level) { + print(msg, color, level, true, false); + } + + public static void printlnGreen(Object msg, int level) { + print(msg, FColor.GREEN, level, true, false); + } + + public static void printlnRed(Object msg, int level) { + print(msg, FColor.RED, level, true, false); + } + + + // Detailed versions of other methods + // - print if only showDetailedLog is true + + public static void detailsPrint(Object msg){ + print(msg, FColor.WHITE, 0, false, true); + } + + public static void detailsPrintColor(Object msg, FColor color) { + print(msg, color, 0, false, true); + } + + public static void detailsPrintGreen(Object msg) { + print(msg, FColor.GREEN, 0, false, true); + } + + public static void detailsPrintRed(Object msg) { + print(msg, FColor.RED, 0, false, true); + } + + public static void detailsPrintln(Object msg, Integer level) { + print(msg, FColor.WHITE, level, true, true); + } + + public static void detailsPrintlnColor(Object msg, FColor color, Integer level) { + print(msg, color, level, true, true); + } + + public static void detailsPrintlnGreen(Object msg, int level) { + print(msg, FColor.GREEN, level, true, true); + } + + public static void detailsPrintlnRed(Object msg, int level) { + print(msg, FColor.RED, level, true, true); + } + + +} diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index c8da2f0..1182428 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -3,6 +3,10 @@ general: done: Done! time: Time... {0} ms addToGit: Adding to git... + commandSuccess: Execute command success! + showDbCredentials: "Getting database connection credentials... {0}:\\{1}@{2}{3}" + gettingRepoLink: Getting link to repo... + repoLink: "Link: {0}" add: processingObject: Processing object {0} savingToFile: Saving to file... @@ -11,15 +15,16 @@ general: size: portion size loading: Loading portion index link: - connectionEstablished: Connection established + connectionEstablished: Testing connection OK... Connection established dblinkCreated: File {0} has been created checkout: do: Do checkout... - toCreateBranch: To create new branch - branchName: Branch name - commitName: Commit name - commitMessage: Commit message - updatedFromIndex: Updated {0} path{1} from the index + toCreateBranch: "To create new branch: {0}" + branchName: "Branch name: {0}" + commitName: "Commit name: {0}" + commitMessage: "Commit message: {0}" + updatedFromIndex: Updated {0} path {1} from the index + printBranchAndCommit: "{0} ({1}) {2}" clone: cloned: Repository cloned commit: @@ -34,8 +39,8 @@ general: dump: checking: Checking files... dumping: Dumping... - hash: hash - dbHash: db hash + hash: "hash: {0}" + dbHash: "db hash {0}" hashesDifferent: Hashes are different, saving to file... hashesMatch: Hashes match, no need to dump object... processing: Processing {0} @@ -103,6 +108,14 @@ general: removingFromIndex: Removing from index... removingFromDb: Removing from db... markingToDelete: Marking item as removing in index + push: + noCommitsFound: No commits found! + remoteName: "remoteName: {0}" + called: Push called... + nullResult: Push result is null! + callResult: "Push call result: {0}" + result: "Push result: {0}" + upToDate: Everything up-to-date status: repVersion: "Repository version: {0}" dbgitVersion: "Dbgit version: {0}" @@ -127,16 +140,32 @@ general: diffDataRow: MetaTableData diff data row {0} {1} {2} {3} loadRow: loading row {0} loadedRow: loaded {0} rows + loadFiles: Loading files... + loadFile: Loading file {0}... backup: tryingToCopy: Trying to copy {0} to {1}... creatingSchema: Creating schema {0} droppingBackup: Dropping backup object {0}... tryToBackup: Try to backup {0} present of {1} restoring objects ... dependingBackups: Found {0} depending backups - {1} - rewritingBackups: Rewriting {0} backups with {1} found dependencies + rewritingBackups: Dropping {0} backups with {1} found dependencies... + creatingBackups: Creating {0} backups... + dbAdapter: + connectionLost: Connection lost, trying to reconnect... + reconnectTrySuccess: Successful reconnect. + reconnectTry: Try {0}... + convert: + processingTable: Converting table {0}... + convertingIndex: Converting table index {0} from {1} to {2} + convertingConstraint: Converting table constraint {0} from {1} to {2} + convertingField: Converting table field {0} from {1} to {2} + convertingSchema: Converting schema {0}... + convertingView: Converting view {0}... errors: + cmdException: "Error execute dbgit: {0}" + onExceptionTransactionRollbackError: "Failed to rollback connection: {0}" commandNotFound: Command {0} not found! - executionError: Error execute dbgit + executionError: Error execute dbgit {0} gitRepNotFound: Git repository not found gitLoginNotFound: Can't find git login gitPasswordNotFound: Can't find git password @@ -152,13 +181,15 @@ errors: fileLoadError: Error load file {0} errorParseIndex: Error parse ItemIndex! errorDump: Error write dump file + unsatisfiedDependencies: "There were objects with unsatisfied dependencies, they will NOT be included in restore list:" + metaTypeError: "The restore adapter encountered wrong MetaObject {0} type: expected {1}, got {2}" hash: errorSha: error search MessageDigest SHA-256 nullParam: Calc hash use null params unsupportedEncode: UnsupportedEncodingException UTF-8 link: emptyLink: Url database is empty - cantConnect: Test connection error + cantConnect: "Test connection error: {0}" restore: restoreErrorDidNotReturnTrue: Error restore objects.... restoreMetaObject must return true if object restore restoreError: Restore objects error @@ -171,6 +202,8 @@ errors: cantConnect: Can't connect to db! errorLoadDelete: Error load and delete object fileAlreadyExists: Error write script, file {0} already exists + emptyFieldsList: Empty fieldList, maybe empty csv... + emptyRowsList: MapRows is null, maybe empty csv... add: badCommand: Bad command. Not found object to add! cantFindObjectInDb: Can't find object {0} in database @@ -202,11 +235,13 @@ errors: encrypted: Could not get ddl of database object {0}, the restoration is impossible tooManyRecords: Table {0} has more than {1} records. dbgit can't save this table data. compareMetaError: compareMeta Error! {0} to {1} + loadMetaFile: Could not load meta file {0}, using dummy version instead! dataTable: errorCellData: Error create CellData for type {0} differentCount: Different count columns title and line fieldNotFound: Field {0} not found filesNotFound: Cound not find .data files in directories '{0}', put NULL values instead + loadPortionError: Error while getting portion of data, try {0} adapter: schemes: Error load schemes! tables: Error load tables! @@ -224,10 +259,16 @@ errors: roles: Error load roles! rollback: Error while rollback! createSchema: Cannot create schema + nullSchema: Object {0} has no schema set! backup: badCommand: Bad command. Object to backup doesn't specified! backupError: Error on backup {0} cannotCreateSchema: Cannot create schema {0} + convert: + cannotConvert: Cannot convert {0}! + cannotFindAdapter: Could not get convert adapter for {0} ({1} version {2} -> {3} version {4}) + pull: + emptyGitRepository: Repo is empty! help: h: Shows this help v: Outputs full log of command execution diff --git a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java index 8462f03..07f192b 100644 --- a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java @@ -209,10 +209,13 @@ public void CmdRestore() throws Exception { scriptFile.delete(); dbgitRestore(true, true, scriptPath); - ConsoleWriter.printlnGreen(MessageFormat.format("Done restore, script: \n{1} ({0} syms.)", - scriptFile.exists() ? FileUtils.readFileToString(scriptFile).length() : 0, - scriptPath - )); + + //TODO assert sizes have no difference + ConsoleWriter.printlnGreen(MessageFormat.format( + "File 1st: {0} syms.\nFile 2nd: {1} syms.", + scriptFile.exists() ? FileUtils.readFileToString(scriptFile).length() : -1, + scriptFileA.exists() ? FileUtils.readFileToString(scriptFileA).length() :- 1 + ), messageLevel); } } @@ -231,6 +234,9 @@ public void CmdAdd() throws Exception { dbgitCheckout(repoBranch, lastCommit, false, true, false, false); IMapMetaObject fileImos = GitMetaDataManager.getInstance().loadFileMetaData(); IMapMetaObject databaseImos = GitMetaDataManager.getInstance().loadDBMetaData(); + + + ConsoleWriter.detailsPrintln("Find file to db object difference: ", messageLevel); MapDifference diffs = Maps.difference(fileImos, databaseImos); ConsoleWriter.detailsPrintLn("Diffs: "); @@ -255,6 +261,8 @@ private static void dbgitReset(String mode) throws Exception { CmdReset cmd = new CmdReset(); Option optionMode = new Option(mode , false, mode); CommandLine.Builder builder = new CommandLine.Builder(); + ConsoleWriter.println(MessageFormat.format("(call) dbgit {0} {1}", "reset", sb.toString()), messageLevel); + cmd.execute(builder.addOption(optionMode).build()); } @@ -321,6 +329,8 @@ private static void dbgitRestore(boolean isRestore, boolean isToMakeBackup, Stri scriptOption.getValuesList().add(scriptPath); builder.addOption(scriptOption); } + + ConsoleWriter.println(MessageFormat.format("(call) dbgit {0} {1}", "checkout", sb.toString()), messageLevel); setToMakeBackup(isToMakeBackup); cmd.execute(builder.build()); @@ -330,6 +340,8 @@ private static void configureTestDb(boolean eraseDatabase) throws Exception { String propDbUrl = System.getProperty("pgTestDbUrl"); String propDbUser = System.getProperty("pgTestDbUser"); String propDbPass = System.getProperty("pgTestDbPass"); + + ConsoleWriter.println("(config) Using test database: ", messageLevel); if(propDbUrl != null){ ConsoleWriter.printlnGreen(MessageFormat.format("Overriding DBConnection url from props: {0}", pgTestDbUrl)); pgTestDbUrl = propDbUrl; @@ -410,15 +422,14 @@ private static void restoreDbLinkIfNeeded() throws Exception { private static void setToMakeBackup(boolean isToMakeBackup) throws Exception { String sectionName = "core"; String parameterName = "TO_MAKE_BACKUP"; - ConsoleWriter.detailsPrintlnRed(MessageFormat.format("+ TO_MAKE_BACKUP was: {0}", - String.valueOf(DBGitConfig.getInstance().getBoolean(sectionName, parameterName, false)) - )); + String was = String.valueOf(DBGitConfig.getInstance().getBoolean(sectionName, parameterName, false)); + DBGitConfig.getInstance().setValue("TO_MAKE_BACKUP", isToMakeBackup ? "true" : "false"); - ConsoleWriter.detailsPrintlnRed(MessageFormat.format("+ TO_MAKE_BACKUP (set, now)): {0}, {1}", - String.valueOf(isToMakeBackup), + ConsoleWriter.detailsPrintlnRed(MessageFormat.format("(config) Set ''TO_MAKE_BACKUP'' (was, set, now): {0}, {1}, {2}", + was, String.valueOf(isToMakeBackup), String.valueOf(DBGitConfig.getInstance().getBoolean(sectionName, parameterName, false)) - )); + ), messageLevel); } private static CommandLine getLinkCommandLine(String url, String user, String pass){ diff --git a/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java b/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java index 4831bd7..cd2759c 100644 --- a/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java @@ -74,6 +74,7 @@ public class DBAdapterMssqlTest { private static String schema; private static String viewName = "TestView"; private static String sequenceName = "TestSequence"; + private static int messageLevel = 0; @Before @@ -924,6 +925,7 @@ public void dropBackupTables() throws Exception{ Map tables = testAdapter.getTables(schema); for (DBTable table : tables.values()){ if(table.getName().startsWith("BACKUP$")){ + ConsoleWriter.println("drop "+table.getName(), messageLevel); dropTable(schema+"."+table.getName()); } } @@ -1283,7 +1285,7 @@ public void dropBigDummyTable() throws Exception{ Statement stmt = testConnection.createStatement(); try { stmt.execute("DROP TABLE tempdb..#bigDummyTable\n"); } catch (SQLException ex) { - ConsoleWriter.println("Failed to drop #bigDummyTable"); + ConsoleWriter.println("Failed to drop #bigDummyTable", messageLevel); } stmt.close(); } From 742bd0755f8e8d8ff0ec4e2959dc3b2f64e5e7b9 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 10 Feb 2021 23:52:26 +0300 Subject: [PATCH 39/68] + Add -noowner key to CmdRestore and CmdCheckout + Add transient (not saved to ini) config to bypass this key (option) to every part of the execution pipeline + Changed restore adapters owner restoration procedure to be aware of this temporal config option --- .../fusionsoft/dbgit/command/CmdCheckout.java | 4 ++ .../fusionsoft/dbgit/command/CmdRestore.java | 3 ++ .../ru/fusionsoft/dbgit/core/DBGitConfig.java | 47 ++++++++++++++++--- .../dbgit/mssql/DBRestoreSchemaMssql.java | 9 ++-- .../dbgit/mssql/DBRestoreTableSpaceMssql.java | 9 ++-- .../dbgit/mssql/DBRestoreViewMssql.java | 7 ++- .../postgres/DBBackupAdapterPostgres.java | 13 +++-- .../postgres/DBRestoreProcedurePostgres.java | 6 +-- .../postgres/DBRestoreSchemaPostgres.java | 11 +++-- .../postgres/DBRestoreSequencePostgres.java | 25 ++++++---- .../postgres/DBRestoreTablePostgres.java | 34 +++++++++----- .../postgres/DBRestoreTableSpacePostgres.java | 4 +- .../dbgit/postgres/DBRestoreViewPostgres.java | 15 ++++-- 13 files changed, 135 insertions(+), 52 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java index c833657..d2573d7 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java @@ -22,6 +22,7 @@ public CmdCheckout() { opts.addOption("r", false, getLang().getValue("help", "checkout-r").toString()); opts.addOption("u", false, getLang().getValue("help", "checkout-u").toString()); opts.addOption("nodb", false, getLang().getValue("help", "checkout-no-db").toString()); + opts.addOption("noowner", false, getLang().getValue("help", "checkout-no-owner").toString()); opts.addOption("upgrade", false, getLang().getValue("help", "checkout-u").toString()); opts.addOption("ls", false, getLang().getValue("help", "checkout-ls").toString()); } @@ -103,6 +104,9 @@ public void execute(CommandLine cmdLine) throws Exception { if (cmdLine.hasOption("r")) { builder.addOption(new Option("r", false, "")); } + if (cmdLine.hasOption("noowner")) { + builder.addOption(new Option("noowner", false, "")); + } if (cmdLine.hasOption("v")) { builder.addOption(new Option("v", false, "")); } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java index 8488951..a16e63f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java @@ -56,6 +56,9 @@ public void execute(CommandLine cmdLine) throws Exception { boolean toMakeChanges = cmdLine.hasOption("r"); boolean toMakeBackup = DBGitConfig.getInstance().getBoolean("core", "TO_MAKE_BACKUP", true); + // from cmdLine to temporary config bypass + // can be used as other config data by restore adapters + DBGitConfig.getInstance().setToIgnoreOnwer(cmdLine.hasOption("noowner")); try { adapter = AdapterFactory.createAdapter(); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java index b09edfb..726ceac 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java @@ -1,6 +1,9 @@ package ru.fusionsoft.dbgit.core; import java.io.File; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; import org.ini4j.Ini; @@ -11,6 +14,7 @@ public class DBGitConfig { private static DBGitConfig config = null; private Ini ini = null; private Ini iniGlobal = null; + private Map transientConfig = new HashMap<>(); private DBGitConfig() throws Exception { @@ -84,16 +88,27 @@ public Double getDoubleGlobal(String section, String option, Double defaultValue private String getString(String section, String option, String defaultValue, boolean global) { try { - String result = global ? iniGlobal.get(section, option) : ini.get(section, option); + String result = global ? iniGlobal.get(section, option) : getIni().get(section, option); return result == null ? defaultValue : result; } catch (Exception e) { return defaultValue; } } + private Ini getIni() throws ExceptionDBGit, IOException { + if(ini == null){ + if (DBGit.checkIfRepositoryExists()) { + File file = new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG); + if (file.exists()) + ini = new Ini(file); + } + } + return ini; + } + private Boolean getBoolean(String section, String option, Boolean defaultValue, boolean global) { try { - String result = global ? iniGlobal.get(section, option) : ini.get(section, option); + String result = global ? iniGlobal.get(section, option) : getIni().get(section, option); return result == null ? defaultValue : Boolean.valueOf(result); } catch (Exception e) { @@ -103,7 +118,7 @@ private Boolean getBoolean(String section, String option, Boolean defaultValue, private Integer getInteger(String section, String option, Integer defaultValue, boolean global) { try { - String result = global ? iniGlobal.get(section, option) : ini.get(section, option); + String result = global ? iniGlobal.get(section, option) : getIni().get(section, option); return result == null ? defaultValue : Integer.valueOf(result); } catch (Exception e) { return defaultValue; @@ -112,7 +127,7 @@ private Integer getInteger(String section, String option, Integer defaultValue, private Double getDouble(String section, String option, Double defaultValue, boolean global) { try { - String result = global ? iniGlobal.get(section, option) : ini.get(section, option); + String result = global ? iniGlobal.get(section, option) : getIni().get(section, option); return result == null ? defaultValue : Double.valueOf(result); } catch (Exception e) { return defaultValue; @@ -140,14 +155,14 @@ public void setValue(String parameter, String value, boolean global) throws Exce iniGlobal.store(iniGlobal.getFile()); } } else { - if (ini == null) + if (getIni() == null) throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "gitRepNotFound")); if (!ini.get("core").containsKey(parameter)) ConsoleWriter.detailsPrintln(DBGitLang.getInstance().getValue("errors", "config", "noParameter").withParams(parameter), messageLevel); else { - ini.get("core").put(parameter, value); - ini.store(new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG)); + getIni().get("core").put(parameter, value); + getIni().store(new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG)); } } } catch (Exception e) { @@ -155,4 +170,22 @@ public void setValue(String parameter, String value, boolean global) throws Exce } } + + public static String TO_IGNORE_OWNER = "noowner"; + + public void setValueTransient(String parameter, String value) throws ExceptionDBGit{ + transientConfig.put(parameter, value); + } + + public String getValueTransient(String parameter, String defaultValue){ + return transientConfig.getOrDefault(parameter, defaultValue); + } + + public void setToIgnoreOnwer(boolean value) throws ExceptionDBGit{ + transientConfig.put(TO_IGNORE_OWNER, value ? "true" : "false"); + } + + public boolean getToIgnoreOnwer(boolean defaultValue){ + return Boolean.valueOf(getValueTransient(TO_IGNORE_OWNER, defaultValue ? "true" : "false")); + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java index 7e30211..356e63e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreSchemaMssql.java @@ -2,6 +2,7 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; import ru.fusionsoft.dbgit.dbobjects.DBSchema; import ru.fusionsoft.dbgit.meta.IMetaObject; @@ -29,13 +30,13 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if(restoreSchema.getObjectOption().getName().equals(sch.getName())){ exist = true; // TODO MSSQL restore Schema script - //String test1 = changedsch.getObjectOption().getName(); - //String test2 = changedsch.getObjectOption().getOptions().getChildren().get("usename").getData(); - if(!restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData().equals(sch.getOptions().getChildren().get("usename").getData())) { + + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + if(!restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData().equals(sch.getOptions().getChildren().get("usename").getData())) { st.execute("ALTER SCHEMA "+ restoreSchema.getObjectOption().getName() +" OWNER TO "+ restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData()); + } } - //TODO Восстановление привилегий } } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java index ff9f34b..4ac2efc 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableSpaceMssql.java @@ -2,6 +2,7 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; import ru.fusionsoft.dbgit.meta.IMetaObject; @@ -40,10 +41,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { String currentowner = tblspace.getOptions().getChildren().get("usename").getData(); String currentloc = tblspace.getOptions().getChildren().get("pg_tablespace_location").getData(); - if(!restoreowner.equals(currentowner)) { - st.execute("alter tablespace "+ restorename +" owner to "+ restoreowner); - } + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + if(!restoreowner.equals(currentowner)) { + st.execute("alter tablespace "+ restorename +" owner to "+ restoreowner); + } + } if(restoreTableSpace.getObjectOption().getOptions().getChildren().containsKey("spcoptions")) { String options = restoreTableSpace.getObjectOption().getOptions().getChildren().get("spcoptions").getData().replaceAll("[\\{\\}]", ""); st.execute("alter tablespace "+ restorename +" set ("+ options+")"); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java index 1cb046e..663a18a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java @@ -2,6 +2,7 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMetaObject; @@ -46,8 +47,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if (!query.endsWith(";")) query = query + ";"; query = query + "\n"; - query+= "ALTER VIEW "+restoreView.getSqlObject().getName() +" OWNER TO "+restoreView.getSqlObject().getOwner()+";\n"; + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + query+= "ALTER VIEW "+restoreView.getSqlObject().getName() +" OWNER TO \""+restoreView.getSqlObject().getOwner()+"\";\n"; + } + st.execute(query); + //TODO Восстановление привилегий } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java index a90af29..faac3af 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBBackupAdapterPostgres.java @@ -80,7 +80,7 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "tryingToCopy").withParams(tableName, getFullDbName(schema, tableName)), messageLevel); StringBuilder tableDdlSb = new StringBuilder(MessageFormat.format( - "create table {0} as (select * from {1}.{2} where 1={3}) {4};\n alter table {0} owner to {5};\n" + "create table {0} as (select * from {1}.{2} where 1={3}) {4};" , backupTableSam , adapter.escapeNameIfNeeded(schema) , adapter.escapeNameIfNeeded(tableName) @@ -91,6 +91,11 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio , metaTable.getTable().getOptions().get("owner").getData() )); + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + String owner = metaTable.getTable().getOptions().get("owner").getData(); + tableDdlSb.append(MessageFormat.format("\nalter table {0} owner to \"{1}\";\n", backupTableSam, owner)); + } + Map fkRefReplaces = new HashMap<>(); for (String fk : metaTable.getTable().getDependencies()){ @@ -173,8 +178,10 @@ public IMetaObject backupDBObject(IMetaObject obj) throws SQLException, Exceptio + " START " + metaSequence.getSequence().getOptions().get("start_value").toString() + "\n" + " MINVALUE " + metaSequence.getSequence().getOptions().get("minimum_value").toString() + "\n" + " MAXVALUE " + metaSequence.getSequence().getOptions().get("maximum_value").toString() + ";\n"; - - ddl += "alter sequence "+ sequenceName + " owner to "+ metaSequence.getSequence().getOptions().get("owner").getData()+";\n"; + + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + ddl += "alter sequence "+ sequenceName + " owner to \""+ metaSequence.getSequence().getOptions().get("owner").getData()+"\";\n"; + } dropIfExists( isSaveToSchema() ? PREFIX + schema : schema, diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java index a01e982..a8edf38 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreProcedurePostgres.java @@ -2,6 +2,7 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; import ru.fusionsoft.dbgit.dbobjects.DBProcedure; @@ -42,13 +43,12 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { ) { st.execute(restoreProc.getSqlObject().getSql()); } - //if owners differ - if(!restoreProc.getSqlObject().getOwner().equals(prc.getOwner())) { + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false) && !restoreProc.getSqlObject().getOwner().equals(prc.getOwner())) { StringProperties restoreProcArgs = restoreProc.getSqlObject().getOptions().get("arguments"); String args = restoreProcArgs != null ? restoreProcArgs.getData().replaceAll("(\\w+ \\w+) (DEFAULT [^\\,\\n]+)(\\,|\\b)", "$1") : ""; - st.execute(MessageFormat.format("ALTER PROCEDURE {0}.{1}({2}) OWNER TO {3}" + st.execute(MessageFormat.format("ALTER PROCEDURE {0}.{1}({2}) OWNER TO \"{3}\"" , nm.getSchema() , adapter.escapeNameIfNeeded(restoreProcName) , args diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java index 9b2a99d..6bce6ca 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSchemaPostgres.java @@ -4,6 +4,7 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; import ru.fusionsoft.dbgit.dbobjects.DBSchema; import ru.fusionsoft.dbgit.meta.IMetaObject; @@ -29,9 +30,13 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { exist = true; //String test1 = changedsch.getObjectOption().getName(); //String test2 = changedsch.getObjectOption().getOptions().getChildren().get("usename").getData(); - if(!restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData().equals(sch.getOptions().getChildren().get("usename").getData())) { - st.execute("ALTER SCHEMA "+ restoreSchema.getObjectOption().getName() +" OWNER TO "+ - restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData()); + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + if(!restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData().equals(sch.getOptions().getChildren().get("usename").getData())) { + st.execute( + "ALTER SCHEMA "+ restoreSchema.getObjectOption().getName() +" OWNER TO \""+ + restoreSchema.getObjectOption().getOptions().getChildren().get("usename").getData() + "\"" + ); + } } //TODO Восстановление привилегий } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java index f3146be..8c91460 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreSequencePostgres.java @@ -5,12 +5,11 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.dbobjects.DBFunction; import ru.fusionsoft.dbgit.dbobjects.DBSequence; import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaFunction; import ru.fusionsoft.dbgit.meta.MetaSequence; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -58,13 +57,17 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { query+="alter sequence "+sequence + " maxvalue "+restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; } - if(!restoreSeq.getSequence().getOptions().get("owner").equals(seq.getOptions().get("owner"))) { - if(seq.getOptions().get("blocking_table") != null){ - String tableName = adapter.escapeNameIfNeeded(seq.getOptions().get("blocking_table").getData()); - query+="alter table "+tableName+ " owner to "+restoreSeq.getSequence().getOptions().get("owner")+";\n"; + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + + if(!restoreSeq.getSequence().getOptions().get("owner").equals(seq.getOptions().get("owner"))) { + if(seq.getOptions().get("blocking_table") != null){ + String tableName = adapter.escapeNameIfNeeded(seq.getOptions().get("blocking_table").getData()); + query+="alter table "+tableName+ " owner to \""+restoreSeq.getSequence().getOptions().get("owner")+"\";\n"; + } + query+="alter sequence "+sequence+" owner to \""+restoreSeq.getSequence().getOptions().get("owner")+"\";\n"; } - query+="alter sequence "+sequence+" owner to "+restoreSeq.getSequence().getOptions().get("owner")+";\n"; } + if(query.length()>1) { st.execute(query); } @@ -84,7 +87,9 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { "start " + restoreSeq.getSequence().getOptions().get("start_value")+"\n"+ "minvalue "+ restoreSeq.getSequence().getOptions().get("minimum_value")+"\n"+ "maxvalue " + restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; - query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to\""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to\""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; + } } else { query+="create sequence \"" + schema + "\".\"" + seqName+"\"" + @@ -93,7 +98,9 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { "start " + restoreSeq.getSequence().getOptions().get("start_value")+"\n"+ "minvalue "+ restoreSeq.getSequence().getOptions().get("minimum_value")+"\n"+ "maxvalue " + restoreSeq.getSequence().getOptions().get("maximum_value")+";\n"; - query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to \""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + query+="alter sequence \""+ schema + "\".\"" + seqName+"\" owner to \""+ restoreSeq.getSequence().getOptions().get("owner")+"\";"; + } } st.execute(query); //TODO Восстановление привилегий diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index f0a4aa6..6702bb6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -7,6 +7,7 @@ import com.google.common.collect.Sets; import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; import ru.fusionsoft.dbgit.core.GitMetaDataManager; @@ -345,12 +346,18 @@ private void createTable(StatementLogging st, MetaTable restoreTable) throws SQL ,restoreTable.getTable().getOptions().getChildren().containsKey("tablespace") ? "tablespace " + restoreTable.getTable().getOptions().get("tablespace").getData() : "" - ,restoreTable.getTable().getOptions().getChildren().containsKey("owner") - ? restoreTable.getTable().getOptions().get("owner").getData() - : "postgres" ); + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + createTableDdl += MessageFormat.format("\n alter table {0}.{1} owner to {2}\n;", + nme.getSchema() ,nme.getName(), + restoreTable.getTable().getOptions().getChildren().containsKey("owner") + ? restoreTable.getTable().getOptions().get("owner").getData() + : "postgres" + ); + } + if (restoreTable.getTable().getOptions().getChildren().containsKey("partkeydef")) { createTableDdl = createTableDdl.replace(" ) ", ") PARTITION BY " + restoreTable.getTable().getOptions().getChildren().get("partkeydef") @@ -359,20 +366,23 @@ private void createTable(StatementLogging st, MetaTable restoreTable) throws SQL st.execute(createTableDdl); } - private void restoreTableOwner(StatementLogging st, MetaTable restoreTable, MetaTable existingTable) throws SQLException, ExceptionDBGit { + private void restoreTableOwner(StatementLogging st, MetaTable restoreTable, MetaTable existingTable) throws Exception { String schema = adapter.escapeNameIfNeeded(getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase())); String tblName = adapter.escapeNameIfNeeded(restoreTable.getTable().getName()); StringProperties exOwner= existingTable.getTable().getOptions().get("owner"); StringProperties restoreOwner = restoreTable.getTable().getOptions().get("owner"); - if(restoreOwner != null && ( exOwner == null || !exOwner.getData().equals(restoreOwner.getData()) ) ){ - String alterTableDdl = MessageFormat.format( - "alter table {0}.{1} owner to {2};\n" - ,schema - ,tblName - ,restoreTable.getTable().getOptions().get("owner").getData() - ); - st.execute(alterTableDdl); + + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + if(restoreOwner != null && ( exOwner == null || !exOwner.getData().equals(restoreOwner.getData()) ) ){ + String alterTableDdl = MessageFormat.format( + "alter table {0}.{1} owner to {2};\n" + ,schema + ,tblName + ,restoreTable.getTable().getOptions().get("owner").getData() + ); + st.execute(alterTableDdl); + } } } private void restoreTableTablespace(StatementLogging st, MetaTable restoreTable, MetaTable existingTable) throws SQLException, ExceptionDBGit { diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java index 9874a35..51ca6e8 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableSpacePostgres.java @@ -39,8 +39,8 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { String currentname = tblspace.getName(); String currentowner = tblspace.getOptions().getChildren().get("usename").getData(); String currentloc = tblspace.getOptions().getChildren().get("pg_tablespace_location").getData(); - - if(!restoreowner.equals(currentowner)) { + + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false) && !restoreowner.equals(currentowner)) { st.execute("alter tablespace "+ restorename +" owner to "+ restoreowner); } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java index 3d89b49..ba9562e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreViewPostgres.java @@ -6,12 +6,11 @@ import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; -import ru.fusionsoft.dbgit.dbobjects.DBTable; import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaTable; import ru.fusionsoft.dbgit.meta.MetaView; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -35,14 +34,20 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if(!restoreView.getSqlObject().getSql().equals(vw.getSql())) { st.execute(getDdlEscaped(restoreView)); } - if(!restoreView.getSqlObject().getOwner().equals(vw.getOwner())) { - st.execute(getChangeOwnerDdl(restoreView, restoreView.getSqlObject().getOwner())); + + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + if(!restoreView.getSqlObject().getOwner().equals(vw.getOwner())) { + st.execute(getChangeOwnerDdl(restoreView, restoreView.getSqlObject().getOwner())); + } } } } } if(!exist){ - String query = getDdlEscaped(restoreView) + getChangeOwnerDdl(restoreView, restoreView.getSqlObject().getOwner()); + String query = getDdlEscaped(restoreView); + if(!DBGitConfig.getInstance().getToIgnoreOnwer(false)){ + query += getChangeOwnerDdl(restoreView, restoreView.getSqlObject().getOwner()); + } st.execute(query); } //TODO Восстановление привилегий ? From 45a7a08bebe489c7fc4d8637b5a2799327b6b879 Mon Sep 17 00:00:00 2001 From: rocket Date: Thu, 11 Feb 2021 00:37:48 +0300 Subject: [PATCH 40/68] + Add DBGitLang throws exception when cannot find text for given path + Fix some console log messages --- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 4 ---- .../ru/fusionsoft/dbgit/core/DBGitLang.java | 22 ++++++++++++++----- .../ru/fusionsoft/dbgit/core/DBGitPath.java | 1 - .../dbgit/mssql/DBRestoreViewMssql.java | 1 - .../dbgit/mysql/DBRestoreSchemaMySql.java | 1 - .../dbgit/mysql/DBRestoreViewMySql.java | 1 - .../mysql/converters/TableConverterMySql.java | 1 + .../dbgit/postgres/DBAdapterPostgres.java | 1 + src/main/resources/lang/eng.yaml | 2 +- 9 files changed, 20 insertions(+), 14 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index d9e0c11..2b7a2c8 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -555,10 +555,6 @@ private CredentialsProvider getCredentialsProvider() throws ExceptionDBGit { private static CredentialsProvider getCredentialsProvider(String link) throws ExceptionDBGit { try { - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("general", "parsingDbCredentials") - , 0 - ); URIish uri = new URIish(link); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitLang.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitLang.java index 82a6451..b4c0698 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitLang.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitLang.java @@ -2,6 +2,7 @@ import java.io.File; import java.io.FileInputStream; +import java.util.Arrays; import java.util.Map; import org.yaml.snakeyaml.Yaml; @@ -29,9 +30,15 @@ private DBGitLang() { path = path.substring(0, i); } - mapValue = (Map) - new Yaml().load(new FileInputStream(new File(path + "/lang/" + - DBGitConfig.getInstance().getString("core", "LANG", DBGitConfig.getInstance().getStringGlobal("core", "LANG", "no")).toLowerCase() + ".yaml"))); + mapValue = new Yaml().load( + new FileInputStream( + new File( + path + + "/lang/" + + DBGitConfig.getInstance().getString("core", "LANG", DBGitConfig.getInstance().getStringGlobal("core", "LANG", "no")).toLowerCase() + + ".yaml") + ) + ); } catch (Exception e) { throw new ExceptionDBGitRunTime(e); } @@ -42,7 +49,7 @@ public static DBGitLang getInstance() { return lang; } - public DBGitLang getValue(String... args) { + public DBGitLang getValue(String... args) throws ExceptionDBGitRunTime { Object val = mapValue; value = ""; for (String arg : args) { @@ -51,8 +58,13 @@ public DBGitLang getValue(String... args) { val = newVal.get(arg); } - if (val != null) + if (val != null){ value = val.toString(); + if(value.equals("")) throw new ExceptionDBGitRunTime("Empty `lang` value for " + Arrays.toString(args)); + } + else { + throw new ExceptionDBGitRunTime("Cannot find `lang` value for " + Arrays.toString(args)); + } return this; } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java index 4f08dee..5955f51 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java @@ -200,7 +200,6 @@ public static boolean createDefaultDbignore(String path, String url, Properties return false; } catch(Exception e) { - e.printStackTrace(); throw new ExceptionDBGit(e); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java index 663a18a..86da9c0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreViewMssql.java @@ -64,7 +64,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java index a415ac5..c4f2e8d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreSchemaMySql.java @@ -29,7 +29,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { )); } } catch (Exception e) { - ConsoleWriter.detailsPrintlnRed(lang.getValue("errors", "meta", "fail")); throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java index 5b0a917..76b1f2d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreViewMySql.java @@ -22,7 +22,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { MetaView restoreView = (MetaView)obj; String ddl = restoreView.getSqlObject().getSql(); st.execute(ddl); - //connect.commit();//FIXME ???? } else { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( obj.getName() diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/converters/TableConverterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/converters/TableConverterMySql.java index d0081f9..aec60b1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/converters/TableConverterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/converters/TableConverterMySql.java @@ -1,6 +1,7 @@ package ru.fusionsoft.dbgit.mysql.converters; import ru.fusionsoft.dbgit.adapters.IDBConvertAdapter; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index dd0b95e..bdac8c1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -11,6 +11,7 @@ import ru.fusionsoft.dbgit.adapters.IFactoryDBBackupAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; import ru.fusionsoft.dbgit.core.DBGitConfig; +import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.core.db.DbType; diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index 1182428..ebf51c1 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -4,7 +4,7 @@ general: time: Time... {0} ms addToGit: Adding to git... commandSuccess: Execute command success! - showDbCredentials: "Getting database connection credentials... {0}:\\{1}@{2}{3}" + showDbCredentials: "Getting database connection credentials... {0}://{1}@{2}{3}" gettingRepoLink: Getting link to repo... repoLink: "Link: {0}" add: From 192f681d74f052626df917d6b0505ce921af572a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=20?= =?UTF-8?q?=D0=93=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D0=BB=D0=BE=D0=B2?= Date: Fri, 7 May 2021 15:15:29 +0200 Subject: [PATCH 41/68] try add SAST --- .gitlab-ci.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index ff47285..dd858d4 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -4,6 +4,9 @@ stages: - test - build +include: + - template: Security/SAST.gitlab-ci.yml + build: stage: build script: From c47f68e19ff70db65d7a39a84d5e2071d6f5d426 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=20?= =?UTF-8?q?=D0=93=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D0=BB=D0=BE=D0=B2?= Date: Wed, 12 May 2021 13:36:18 +0200 Subject: [PATCH 42/68] allow failure tests --- .gitlab-ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index dd858d4..b68384b 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -23,6 +23,7 @@ test: stage: test script: - time mvn test + allow_failure: true cache: paths: From 54b0e5b6f2c8db3e27ed241f85a1f2590f75ee8c Mon Sep 17 00:00:00 2001 From: rocket Date: Sat, 20 Feb 2021 23:10:58 +0300 Subject: [PATCH 43/68] Multiple refactor to make code base behaviour and data flow more predictable Fix NotNull constraints workaround for postgres DBMS --- .../fusionsoft/dbgit/adapters/DBAdapter.java | 31 +- .../dbgit/adapters/DBBackupAdapter.java | 34 +- .../ru/fusionsoft/dbgit/command/CmdDump.java | 6 +- .../dbgit/core/GitMetaDataManager.java | 8 +- .../ru/fusionsoft/dbgit/dbobjects/DBCode.java | 20 +- .../dbgit/dbobjects/DBConstraint.java | 35 +- .../dbgit/dbobjects/DBFunction.java | 14 +- .../fusionsoft/dbgit/dbobjects/DBIndex.java | 33 +- .../dbgit/dbobjects/DBOptionsObject.java | 56 +- .../fusionsoft/dbgit/dbobjects/DBPackage.java | 14 +- .../dbgit/dbobjects/DBProcedure.java | 11 +- .../ru/fusionsoft/dbgit/dbobjects/DBRole.java | 8 +- .../dbgit/dbobjects/DBSQLObject.java | 50 +- .../fusionsoft/dbgit/dbobjects/DBSchema.java | 10 +- .../dbgit/dbobjects/DBSchemaObject.java | 36 +- .../dbgit/dbobjects/DBSequence.java | 44 +- .../fusionsoft/dbgit/dbobjects/DBTable.java | 33 +- .../dbgit/dbobjects/DBTableField.java | 71 +- .../dbgit/dbobjects/DBTableSpace.java | 12 +- .../fusionsoft/dbgit/dbobjects/DBTrigger.java | 10 +- .../ru/fusionsoft/dbgit/dbobjects/DBUser.java | 8 +- .../ru/fusionsoft/dbgit/dbobjects/DBView.java | 13 +- .../ru/fusionsoft/dbgit/meta/IMetaObject.java | 5 + .../ru/fusionsoft/dbgit/meta/MetaBase.java | 29 +- .../fusionsoft/dbgit/meta/MetaFunction.java | 5 - .../fusionsoft/dbgit/meta/MetaObjOptions.java | 20 +- .../dbgit/meta/MetaObjectFactory.java | 25 +- .../ru/fusionsoft/dbgit/meta/MetaSql.java | 35 +- .../ru/fusionsoft/dbgit/meta/MetaTable.java | 33 +- .../fusionsoft/dbgit/meta/MetaTableData.java | 6 +- .../dbgit/meta/SortedListMetaObject.java | 56 +- .../dbgit/mssql/DBAdapterMssql.java | 63 +- .../dbgit/mysql/DBAdapterMySql.java | 549 +++---- .../dbgit/mysql/DBRestoreTableMySql.java | 8 +- .../dbgit/oracle/DBAdapterOracle.java | 483 +++--- .../dbgit/oracle/DBRestoreTableOracle.java | 8 +- .../dbgit/postgres/DBAdapterPostgres.java | 1321 +++++++++-------- .../postgres/DBRestoreFunctionPostgres.java | 4 +- .../postgres/DBRestoreTablePostgres.java | 164 +- .../postgres/DBRestoreTriggerPostgres.java | 3 - .../dbgit/utils/StringProperties.java | 48 +- src/main/resources/lang/eng.yaml | 2 + 42 files changed, 1739 insertions(+), 1685 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index 563154c..e128dee 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -1,5 +1,6 @@ package ru.fusionsoft.dbgit.adapters; +import com.axiomalaska.jdbc.NamedParameterPreparedStatement; import com.diogonunes.jcdp.color.api.Ansi; import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.core.db.FieldType; @@ -14,9 +15,11 @@ import java.io.OutputStream; import java.sql.Connection; import java.sql.ResultSet; +import java.sql.SQLException; import java.sql.Timestamp; import java.text.MessageFormat; import java.util.List; +import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; import java.util.regex.Matcher; @@ -44,7 +47,7 @@ public void setConnection(Connection conn) { public Connection getConnection() { try { int maxTriesCount = DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000)); - int pauseTimeSeconds = DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000)); + int pauseTimeSeconds = DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 2)); int currentTry = 0; if (connect.isValid(0)){ @@ -65,7 +68,7 @@ public Connection getConnection() { ); DBConnection conn = DBConnection.getInstance(false); if (conn.testingConnection()) { - conn.flushConnection(); +// conn.flushConnection(); conn = DBConnection.getInstance(true); ConsoleWriter.println(DBGitLang.getInstance() .getValue("general", "dbAdapter", "reconnectTrySuccess") @@ -200,17 +203,7 @@ public void deleteDataBase(IMapMetaObject deleteObjs, boolean isDeleteFromIndex) } } - public void rowToProperties(ResultSet rs, StringProperties properties) { - try { - for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) { - if (rs.getString(i) == null) continue ; - properties.addChild(rs.getMetaData().getColumnName(i).toLowerCase(), cleanString(rs.getString(i))); - } - } catch(Exception e) { - throw new ExceptionDBGitRunTime(e); - } - } public String cleanString(String str) { String dt = str.replace("\r\n", "\n"); while (dt.contains(" \n")) dt = dt.replace(" \n", "\n"); @@ -356,4 +349,18 @@ public void registryMappingTypes() { public String escapeNameIfNeeded(String name) { return name; } + + public NamedParameterPreparedStatement preparedStatement(Connection connection, String sql, Map values) throws SQLException, ExceptionDBGit { + NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(getConnection(), sql); + + for(Map.Entry entry : values.entrySet()){ + Object value = entry.getValue(); + if (value instanceof String) stmt.setString(entry.getKey(), (String) value); + else if (value instanceof Long) stmt.setLong(entry.getKey(), (Long) value); + else if (value instanceof Float) stmt.setDouble(entry.getKey(), ((Float) value).floatValue()); + else throw new ExceptionDBGit("Unsupported type of value, see stacktrace"); + } + + return stmt; + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java index f872f5d..6efd7b4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java @@ -59,8 +59,8 @@ public boolean isExists(IMetaObject imo) { public void backupDatabase(IMapMetaObject updateObjs) throws Exception { - // Condition: we should not refer from backups on non-backup objects - // -> we need to backup restoring objects dependencies + // Condition: we rewrite refs on backup objects adding BACKUP$ prefix on them + // -> we need to find and add to backup list all updateObjs dependencies // Condition: old backups can refer on each other // -> we need to drop old backups of the objects + old backup dependencies @@ -80,7 +80,7 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { .filter(x -> !updateObjs.containsKey(x.getName())) .collect(Collectors.toList()); - IMapMetaObject dbAllBackups = new TreeMapMetaObject(dbObjs.values().stream() + IMapMetaObject dbExistingBackups = new TreeMapMetaObject(dbObjs.values().stream() .filter(this::isBackupObject) .collect(Collectors.toList())); @@ -95,39 +95,42 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { // collect restore objects dependencies to satisfy all backups create needs // so dependencies will be backed up too - Map addedObjs; + Map restoreObjsDependencies; do{ - addedObjs = dbNotToBackup.stream().filter( notToBackup -> + restoreObjsDependencies = dbNotToBackup.stream().filter( notToBackup -> notToBackup.getUnderlyingDbObject() != null && dbToBackup.values().stream().anyMatch( toBackup -> toBackup.dependsOn(notToBackup) ) ).collect(Collectors.toMap(IMetaObject::getName, Function.identity() )); - dbNotToBackup.removeAll(addedObjs.values()); - dbToBackup.putAll(addedObjs); + dbNotToBackup.removeAll(restoreObjsDependencies.values()); + dbToBackup.putAll(restoreObjsDependencies); - if(addedObjs.size() > 0) { + if(restoreObjsDependencies.size() > 0) { ConsoleWriter.println(DBGitLang.getInstance() .getValue("general", "backup", "dependingBackups") .withParams( - String.valueOf(addedObjs.size()), - String.join(" ,", addedObjs.keySet()) + String.valueOf(restoreObjsDependencies.size()), + String.join(" ,", restoreObjsDependencies.keySet()) ), 2 ); } - } while (addedObjs.size() > 0); + } while (restoreObjsDependencies.size() > 0); //so we have a full backup list, let's get a drop list if(dbToBackup.size() > 0){ - Set suspectBackupNames = dbToBackup.values().stream().map( x->getBackupNameMeta(x).getMetaName()).collect(Collectors.toSet()); + Set suspectBackupNames = dbToBackup.values().stream() + .map( x->getBackupNameMeta(x).getMetaName()) + .collect(Collectors.toSet()); + List dropList = new ArrayList<>(); - IMapMetaObject dbDroppingBackups = new TreeMapMetaObject(dbAllBackups.values().stream() - .filter(dbBackup -> suspectBackupNames.contains(dbBackup.getName())) + IMapMetaObject dbDroppingBackups = new TreeMapMetaObject(dbExistingBackups.values().stream() + .filter(existingBackup -> suspectBackupNames.contains(existingBackup.getName())) .collect(Collectors.toList())); - List dbDroppingBackupsDeps = dbAllBackups.values().stream() + List dbDroppingBackupsDeps = dbExistingBackups.values().stream() .filter( dbBackup -> !dbDroppingBackups.containsKey(dbBackup.getName()) && dbDroppingBackups.values().stream().anyMatch(dbBackup::dependsOn) @@ -149,7 +152,6 @@ public void backupDatabase(IMapMetaObject updateObjs) throws Exception { for(IMetaObject imo : dropListSorted){ ConsoleWriter.detailsPrintln(lang.getValue("general", "backup", "droppingBackup").withParams(imo.getName()), messageLevel); dropIfExists(imo, stLog); - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java index c8759f7..caec41b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdDump.java @@ -6,11 +6,7 @@ import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.Options; -import ru.fusionsoft.dbgit.core.DBGit; -import ru.fusionsoft.dbgit.core.DBGitIndex; -import ru.fusionsoft.dbgit.core.DBGitPath; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.GitMetaDataManager; +import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.meta.IMapMetaObject; import ru.fusionsoft.dbgit.meta.IMetaObject; import ru.fusionsoft.dbgit.utils.ConsoleWriter; diff --git a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java index 3aa062c..dca494b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java @@ -38,10 +38,10 @@ */ public class GitMetaDataManager { private static GitMetaDataManager manager = null; - - protected IMapMetaObject dbObjs; - protected IMapMetaObject fileObjs; - + + protected IMapMetaObject dbObjs; + protected IMapMetaObject fileObjs; + private MetaTableData currentPortion = null; private int currentPortionIndex = 0; private static int messageLevel = 1; diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBCode.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBCode.java index beb735d..8510527 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBCode.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBCode.java @@ -1,6 +1,8 @@ package ru.fusionsoft.dbgit.dbobjects; -import ru.fusionsoft.dbgit.meta.DBGitMetaType; +import ru.fusionsoft.dbgit.utils.StringProperties; + +import java.util.Set; /** * Base class for all Objects BD with code style @@ -8,17 +10,7 @@ * */ public class DBCode extends DBSQLObject { - /* - private DBGitMetaType type; //pkg, fun, prc, trg - - public DBGitMetaType getType() { - return type; - } - - public void setType(DBGitMetaType type) { - this.type = type; - } - - */ - + public DBCode(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBConstraint.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBConstraint.java index 4eebd98..fe139c5 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBConstraint.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBConstraint.java @@ -1,12 +1,23 @@ package ru.fusionsoft.dbgit.dbobjects; import ru.fusionsoft.dbgit.utils.CalcHash; +import ru.fusionsoft.dbgit.utils.StringProperties; +import ru.fusionsoft.dbgit.yaml.YamlOrder; import java.util.Objects; +import java.util.Set; public class DBConstraint extends DBSQLObject { + + @YamlOrder(4) private String constraintType; - + + public DBConstraint(String name, StringProperties options, String schema, String owner, Set dependencies, String sql, String constraintType) { + super(name, options, schema, owner, dependencies, sql); + this.constraintType = constraintType; + } + + public String getConstraintType() { return constraintType; } @@ -14,26 +25,4 @@ public void setConstraintType(String constraintType) { this.constraintType = constraintType; } - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - DBConstraint that = (DBConstraint) o; - return Objects.equals(constraintType, that.constraintType) - && getName().equalsIgnoreCase(that.getName()) - && getSchema().equalsIgnoreCase(that.getSchema()) - && getSql().replaceAll("\\s+", "").equalsIgnoreCase(that.getSql().replaceAll("\\s+", "")); -// && getOptions().get("tablespace").getData().equalsIgnoreCase(that.getOptions().get("tablespace").getData()); - } - - public String getHash() { - CalcHash ch = new CalcHash(); - ch.addData(getSchema()); - ch.addData(getName()); - ch.addData(getSql().replaceAll("\\s+", "").toLowerCase()); - //TODO !!! - - return ch.calcHashStr(); - } - } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBFunction.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBFunction.java index 0f11f51..790997a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBFunction.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBFunction.java @@ -1,15 +1,13 @@ package ru.fusionsoft.dbgit.dbobjects; + import ru.fusionsoft.dbgit.utils.StringProperties; +import java.util.Set; + public class DBFunction extends DBCode { - - public DBFunction() { - - } - public DBFunction(String name) { - super(); - this.name = name; - } + public DBFunction(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBIndex.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBIndex.java index 32ada71..c1879e0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBIndex.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBIndex.java @@ -3,36 +3,11 @@ import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.utils.StringProperties; -public class DBIndex extends DBSQLObject { - //private DBTable table; - private StringProperties options = new StringProperties(); - public DBIndex() { - super(); - } - public DBIndex(String name) { - super(); - this.name = name; - } - - - public StringProperties getOptions() { - return options; - } +import java.util.Set; - public void setOptions(StringProperties options) { - this.options = options; - } - - public String getSql() { - return options.get("ddl") != null ? options.get("ddl").toString() : ""; - } +public class DBIndex extends DBSQLObject { - public String getHash() { - CalcHash ch = new CalcHash(); - ch.addData(getSchema()); - ch.addData(getName()); - ch.addData(getSql().replaceAll("\\s+", "").toLowerCase()); - return ch.calcHashStr(); + public DBIndex(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); } - } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBOptionsObject.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBOptionsObject.java index eb6d57a..87df219 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBOptionsObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBOptionsObject.java @@ -2,43 +2,61 @@ import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.utils.StringProperties; +import ru.fusionsoft.dbgit.yaml.YamlOrder; + +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; public class DBOptionsObject implements IDBObject { - private String name; - private StringProperties options = new StringProperties(); - - public DBOptionsObject() {} - public DBOptionsObject(String name) { - this.setName(name); - } + @YamlOrder(0) + String name; + + @YamlOrder(99) + StringProperties options; + public DBOptionsObject(String name, StringProperties options) { - this.setName(name); - this.setOptions(options); + this.name = name; + this.options = options; + } + + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof DBOptionsObject)) return false; + + DBOptionsObject that = (DBOptionsObject) o; + return this.getHash().equals(that.getHash()); } - + + @Override + public int hashCode() { + return Objects.hash(getHash()); + } + + public String getHash() { + CalcHash ch = new CalcHash(); + ch.addData(this.name); + ch.addData(this.options.toString()); + + return ch.calcHashStr(); + } + public StringProperties getOptions() { return options; } - public void setOptions(StringProperties opt) { options = opt; } - public String getName() { return name; } - public void setName(String name) { this.name = name; } - public String getHash() { - CalcHash ch = new CalcHash(); - ch.addData(this.getName()); - ch.addData(this.getOptions().toString()); - return ch.calcHashStr(); - } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBPackage.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBPackage.java index 0a657c5..4c49f61 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBPackage.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBPackage.java @@ -1,12 +1,12 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.utils.StringProperties; + +import java.util.Set; + public class DBPackage extends DBCode { - public DBPackage() { } - - public DBPackage(String name) { - super(); - this.name = name; - } - + public DBPackage(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBProcedure.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBProcedure.java index 9865343..b4e8f75 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBProcedure.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBProcedure.java @@ -1,11 +1,12 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.utils.StringProperties; + +import java.util.Set; + public class DBProcedure extends DBCode { - public DBProcedure() { } - - public DBProcedure(String name) { - super(); - this.name = name; + public DBProcedure(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBRole.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBRole.java index c31eff4..196d46d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBRole.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBRole.java @@ -1,10 +1,10 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.utils.StringProperties; + public class DBRole extends DBOptionsObject { - public DBRole() {} - public DBRole(String name) { - super(name); + public DBRole(String name, StringProperties options) { + super(name, options); } - } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java index 6a63941..9cb440a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java @@ -1,7 +1,6 @@ package ru.fusionsoft.dbgit.dbobjects; import ru.fusionsoft.dbgit.utils.CalcHash; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.StringProperties; import java.util.HashSet; @@ -15,49 +14,30 @@ public class DBSQLObject extends DBSchemaObject { protected String sql; - protected String owner; - private StringProperties options = new StringProperties(); + + public DBSQLObject(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies); + this.sql = sql; + } public String getHash() { - CalcHash ch = new CalcHash();/*{ - @Override public CalcHash addData(String data){ - ConsoleWriter.detailsPrintlnGreen("CH| " + data); - return super.addData(data); - } - @Override public String calcHashStr(){ - String result = super.calcHashStr(); - ConsoleWriter.detailsPrintlnRed("RES| " + result + "\n"); - return result; - } - - };*/ - ch.addData(getSchema()); - ch.addData(getName()); - ch.addData(getSql().trim().replaceAll("\\s+", "")); - if (getOwner() != null) - ch.addData(getOwner()); + CalcHash ch = new CalcHash(); + + ch.addData(this.name); + ch.addData(this.schema); + ch.addData(this.owner); + ch.addData(this.options.toString()); + ch.addData(this.sql); return ch.calcHashStr(); } public String getSql() { - return options.get("ddl") != null ? options.get("ddl").toString() : ""; - } - public void setSql(String ddl) { if(options.get("ddl") != null) options.get("ddl").setData(ddl); } - - public String getOwner() { - return owner; - } - - public void setOwner(String owner) { - this.owner=owner; + return this.sql; } - public StringProperties getOptions() { - return options; + public void setSql(String ddl) { + this.sql = ddl; } - public void setOptions(StringProperties options) { - this.options = options; - } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchema.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchema.java index d8b444f..2528b9a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchema.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchema.java @@ -1,12 +1,10 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.utils.StringProperties; + public class DBSchema extends DBOptionsObject { - public DBSchema() { - super(""); - } - - public DBSchema(String name) { - super(name); + public DBSchema(String name, StringProperties options) { + super(name, options); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchemaObject.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchemaObject.java index c01c5a8..c2763f9 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchemaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchemaObject.java @@ -1,6 +1,9 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.utils.StringProperties; +import ru.fusionsoft.dbgit.yaml.YamlOrder; + import java.util.HashSet; import java.util.Set; @@ -9,17 +12,25 @@ * @author mikle * */ -public abstract class DBSchemaObject implements IDBObject { - protected String name; +public abstract class DBSchemaObject extends DBOptionsObject { + + @YamlOrder(1) protected String schema; - private Set dependencies = new HashSet<>(); - - public String getName() { - return name; - } - public void setName(String name) { - this.name = name; + + @YamlOrder(2) + protected String owner; + + @YamlOrder(3) + private Set dependencies; + + + public DBSchemaObject(String name, StringProperties options, String schema, String owner, Set dependencies) { + super(name, options); + this.schema = schema; + this.owner = owner; + this.dependencies = dependencies; } + public String getSchema() { return schema; } @@ -33,5 +44,12 @@ public Set getDependencies() { public void setDependencies(Set dependencies) { this.dependencies = dependencies; } + + public String getOwner() { + return owner; + } + public void setOwner(String owner) { + this.owner=owner; + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java index 77f991e..614335d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java @@ -3,46 +3,42 @@ import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.utils.StringProperties; +import java.util.Set; + public class DBSequence extends DBSchemaObject { protected Long value; - private StringProperties options = new StringProperties(); - - public DBSequence() { } - - public DBSequence(String name) { this.name = name; } - - public Long getValue() { - return value; - } - public void setValue(Long value) { + public DBSequence(String name, StringProperties options, String schema, String owner, Set dependencies, Long value) { + super(name, options, schema, owner, dependencies); this.value = value; } - - public StringProperties getOptions() { - return options; - } - private StringProperties getOptionsFiltered() { + public StringProperties persistentOptions() { + //Immutable, yeah StringProperties props = new StringProperties(getOptions().getData()); props.setChildren(getOptions().getChildren()); props.deleteChild("blocking_table"); return props; } - - public void setOptions(StringProperties options) { - this.options = options; - } - + @Override public String getHash() { CalcHash ch = new CalcHash(); - ch.addData(getSchema()); - ch.addData(getName()); - ch.addData(getOptionsFiltered().toString()); - ch.addData(getValue().toString()); + ch.addData(this.schema); + ch.addData(this.name); + ch.addData(this.owner); + ch.addData(persistentOptions().toString()); + ch.addData(String.valueOf(this.value)); return ch.calcHashStr(); } + + public Long getValue() { + return value; + } + + public void setValue(Long value) { + this.value = value; + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java index 38f1b7d..25a0ad7 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java @@ -1,31 +1,22 @@ package ru.fusionsoft.dbgit.dbobjects; import ru.fusionsoft.dbgit.utils.CalcHash; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.StringProperties; +import ru.fusionsoft.dbgit.yaml.YamlOrder; -public class DBTable extends DBSchemaObject { - private StringProperties options = new StringProperties(); - private String comment = ""; +import java.util.Set; - public DBTable() { - super(); - } +public class DBTable extends DBSchemaObject { - public DBTable(String name) { - super(); - this.name = name; - } + @YamlOrder(4) + private String comment; - public StringProperties getOptions() { - return options; + public DBTable(String name, StringProperties options, String schema, String owner, Set dependencies, String comment) { + super(name, options, schema, owner, dependencies); + this.comment = comment; } - public void setOptions(StringProperties options) { - this.options = options; - } - public String getHash() { CalcHash ch = new CalcHash()/*{ public CalcHash addData(String str){ @@ -33,9 +24,11 @@ public CalcHash addData(String str){ return super.addData(str); } }*/; - ch.addData(this.getName()); - ch.addData(this.getOptions().toString().replaceAll("\\s+", "")); - + ch.addData(this.name); + ch.addData(this.schema); + ch.addData(this.owner); + ch.addData(this.options.toString()); + ch.addData(this.comment); return ch.calcHashStr(); } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java index a8e2598..2938994 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java @@ -5,6 +5,8 @@ import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import java.util.Objects; + public class DBTableField implements IDBObject, Comparable { private String name; private String description; @@ -17,35 +19,57 @@ public class DBTableField implements IDBObject, Comparable { private Integer order = 0; private Boolean isNullable; private Boolean isNameExactly = false; - private String defaultValue; - + private String defaultValue; private Boolean isPrimaryKey = false; - public Boolean getIsPrimaryKey() { - return isPrimaryKey; + @Override + public int compareTo(DBTableField o) { + int res = - isPrimaryKey.compareTo(o.getIsPrimaryKey()); + if (res != 0) return res; + return order.compareTo(o.getOrder()); +// return name.compareTo(o.getName()); } - public void setIsPrimaryKey(Boolean isPrimaryKey) { - this.isPrimaryKey = isPrimaryKey; + @Override public boolean equals(Object obj){ + boolean equals = obj == this; + if(!equals && obj instanceof DBTableField){ + return ((DBTableField) obj).getHash().equals(this.getHash()); + } + return equals; + } + + @Override + public int hashCode() { + return Objects.hash(getHash()); } public String getHash() { CalcHash ch = new CalcHash(); - ch.addData(this.getName()); - ch.addData(this.getTypeSQL()); - ch.addData(this.getFixed()); - ch.addData(this.getLength()); - ch.addData(this.getPrecision()); - ch.addData(this.getScale()); - if( this.getDefaultValue()!=null ) ch.addData(this.getDefaultValue()); - if( this.getIsNullable()!=null ) ch.addData(this.getIsNullable()); - -// if( this.getOrder()!=null ) ch.addData(String.valueOf(this.getOrder())); - ch.addData(isPrimaryKey.toString()); + + ch.addData(this.name); + ch.addData(this.typeSQL); + ch.addData(this.order); + ch.addData(this.isPrimaryKey); + ch.addData(this.isNullable); + ch.addData(this.description); + ch.addData(this.defaultValue); + ch.addData(this.fixed); + ch.addData(this.length); + ch.addData(this.precision); + ch.addData(this.scale); return ch.calcHashStr(); } + + public Boolean getIsPrimaryKey() { + return isPrimaryKey; + } + + public void setIsPrimaryKey(Boolean isPrimaryKey) { + this.isPrimaryKey = isPrimaryKey; + } + public Boolean getIsNullable() { return isNullable; } public void setIsNullable(Boolean isNullable) { this.isNullable = isNullable; } @@ -138,20 +162,7 @@ public void setDescription(String description) { this.description = description; } - @Override - public int compareTo(DBTableField o) { - int res = - isPrimaryKey.compareTo(o.getIsPrimaryKey()); - if (res != 0) return res; - return name.compareTo(o.getName()); - } - @Override public boolean equals(Object obj){ - boolean equals = obj == this; - if(!equals && obj instanceof DBTableField){ - return ((DBTableField) obj).getHash().equals(this.getHash()); - } - return equals; - } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableSpace.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableSpace.java index 7213cd9..b4c6b38 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableSpace.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableSpace.java @@ -1,12 +1,10 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.utils.StringProperties; + public class DBTableSpace extends DBOptionsObject { - - public DBTableSpace() { - super(""); - } - - public DBTableSpace(String name) { - super(name); + + public DBTableSpace(String name, StringProperties options) { + super(name, options); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTrigger.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTrigger.java index 7c9aa09..ccb6a80 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTrigger.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTrigger.java @@ -2,11 +2,11 @@ import ru.fusionsoft.dbgit.utils.StringProperties; +import java.util.Set; + public class DBTrigger extends DBCode { - public DBTrigger() { - - } - public DBTrigger(String name) { - this.name = name; + + public DBTrigger(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBUser.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBUser.java index e27d3ed..90820ed 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBUser.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBUser.java @@ -3,11 +3,7 @@ import ru.fusionsoft.dbgit.utils.StringProperties; public class DBUser extends DBOptionsObject { - public DBUser() {} - - public DBUser(String name) { - super(name); + public DBUser(String name, StringProperties options) { + super(name, options); } - - public DBUser(String name, StringProperties options) { super(name, options); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBView.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBView.java index e0ede68..3587dea 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBView.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBView.java @@ -1,13 +1,12 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.utils.StringProperties; + +import java.util.Set; + public class DBView extends DBSQLObject { - public DBView(String name) { - super(); - this.name = name; + public DBView(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); } - public DBView() { - super(); - } - } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java index 57b6808..c5c7354 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java @@ -7,6 +7,8 @@ import java.io.InputStream; import java.io.OutputStream; import java.lang.reflect.Constructor; +import java.util.Map; + import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.DBGitPath; @@ -87,6 +89,8 @@ public default IMetaObject deSerialize(File file) throws Exception { return this; }; + public Map toMap(); + /** * load current object from DB */ @@ -157,6 +161,7 @@ default IMetaObject loadFromFile() throws Exception { default DBSchemaObject getUnderlyingDbObject(){ //All in one place if(this instanceof MetaSql) return ((MetaSql) this).getSqlObject(); + if(this instanceof MetaSequence) return ((MetaSequence) this).getSequence(); if(this instanceof MetaTable) return ((MetaTable) this).getTable(); return null; } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java index 4b6e70d..f408ab0 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java @@ -1,15 +1,13 @@ package ru.fusionsoft.dbgit.meta; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; +import java.io.*; import java.nio.charset.Charset; +import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.yaml.snakeyaml.DumperOptions; import org.yaml.snakeyaml.Yaml; -import org.yaml.snakeyaml.DumperOptions.ScalarStyle; import org.yaml.snakeyaml.nodes.Tag; import ru.fusionsoft.dbgit.adapters.AdapterFactory; @@ -18,7 +16,6 @@ import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.core.db.DbType; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.yaml.DBGitYamlConstructor; import ru.fusionsoft.dbgit.yaml.DBGitYamlRepresenter; import ru.fusionsoft.dbgit.yaml.YamlOrder; @@ -36,7 +33,7 @@ public abstract class MetaBase implements IMetaObject { @YamlOrder(1) protected DbType dbType; - @YamlOrder(1) + @YamlOrder(2) protected String dbVersion; @Override @@ -102,6 +99,13 @@ public IMetaObject yamlDeSerialize(InputStream stream) { IMetaObject meta = yaml.loadAs(stream, this.getClass()); return meta; } + + public Map toMap() { + Yaml yaml = createYaml(); + String output = yaml.dumpAs(this, Tag.MAP, DumperOptions.FlowStyle.BLOCK); + Map meta = yaml.loadAs(output, Map.class); + return meta; + } public Yaml createYaml() { DumperOptions options = new DumperOptions(); @@ -143,5 +147,16 @@ public void setDbVersion() { } - + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof MetaBase)) return false; + MetaBase metaBase = (MetaBase) o; + return getHash().equals(metaBase.getHash()); + } + + @Override + public int hashCode() { + return getHash().hashCode(); + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaFunction.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaFunction.java index 66eff5f..09d6a0e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaFunction.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaFunction.java @@ -21,11 +21,6 @@ public DBGitMetaType getType() { return DBGitMetaType.DbGitFunction; } - @Override - public String getName() { - return name; - } - @Override public String getFileName(){ String res = name.replace(".fnc", ""); diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaObjOptions.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaObjOptions.java index 8063e44..d4f5d8b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaObjOptions.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaObjOptions.java @@ -4,15 +4,14 @@ import java.io.InputStream; import java.io.OutputStream; import java.util.Map; +import java.util.Objects; -import ru.fusionsoft.dbgit.adapters.AdapterFactory; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitObjectNotFound; import ru.fusionsoft.dbgit.dbobjects.DBOptionsObject; -import ru.fusionsoft.dbgit.dbobjects.DBUser; import ru.fusionsoft.dbgit.utils.CalcHash; +import ru.fusionsoft.dbgit.yaml.YamlOrder; /** * Base Meta class for data use DBOptionsObject information. This data is tree string properties. @@ -21,6 +20,7 @@ */ public abstract class MetaObjOptions extends MetaBase { + @YamlOrder(4) private DBOptionsObject objectOption = null; public MetaObjOptions() { @@ -48,7 +48,7 @@ public boolean serialize(OutputStream stream) throws IOException { } @Override - public IMetaObject deSerialize(InputStream stream) throws IOException{ + public IMetaObject deSerialize(InputStream stream) { return yamlDeSerialize(stream); } @@ -75,4 +75,16 @@ public void setObjectOptionFromMap(Map map) t setObjectOption(map.get(nm.getName())); } + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof MetaObjOptions)) return false; + MetaObjOptions that = (MetaObjOptions) o; + return getObjectOption().getHash().equals(that.getObjectOption().getHash()); + } + + @Override + public int hashCode() { + return Objects.hash(getObjectOption()); + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaObjectFactory.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaObjectFactory.java index ca303bd..0beb554 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaObjectFactory.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaObjectFactory.java @@ -46,21 +46,18 @@ public static IMetaObject createMetaObject(IDBGitMetaType tp) throws ExceptionDB } - public static NameMeta parseMetaName(String name) throws ExceptionDBGit { - try { - NameMeta nm = new NameMeta(); - - Integer pos = name.lastIndexOf("/"); - if (pos > 0) { - nm.setSchema(name.substring(0, pos)); - } - Integer posDot = name.lastIndexOf("."); - nm.setName(name.substring(pos+1, posDot)); - nm.setType(DBGitMetaType.valueByCode(name.substring(posDot + 1))); + public static NameMeta parseMetaName(String name) { + NameMeta nm = new NameMeta(); - return nm; - } catch(Exception e) { - throw new ExceptionDBGitRunTime(DBGitLang.getInstance().getValue("errors", "meta", "parseError").withParams(name), e); + Integer pos = name.lastIndexOf("/"); + if (pos > 0) { + nm.setSchema(name.substring(0, pos)); } + Integer posDot = name.lastIndexOf("."); + nm.setName(name.substring(pos+1, posDot)); + nm.setType(DBGitMetaType.valueByCode(name.substring(posDot + 1))); + + return nm; + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaSql.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaSql.java index 78667f9..252b331 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaSql.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaSql.java @@ -1,18 +1,10 @@ package ru.fusionsoft.dbgit.meta; +import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; -import java.io.StringWriter; -import java.nio.charset.Charset; -import java.nio.charset.StandardCharsets; -import java.util.Map; -import org.apache.commons.io.IOUtils; - -import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitObjectNotFound; -import ru.fusionsoft.dbgit.dbobjects.DBOptionsObject; import ru.fusionsoft.dbgit.dbobjects.DBSQLObject; /** @@ -28,12 +20,12 @@ public MetaSql() { setDbType(); setDbVersion(); } - + public MetaSql(DBSQLObject sqlObject) throws ExceptionDBGit { this(); setSqlObject(sqlObject); - } - + } + public DBSQLObject getSqlObject() { return sqlObject; } @@ -45,7 +37,7 @@ public void setSqlObject(DBSQLObject sqlObject) throws ExceptionDBGit { } @Override - public boolean serialize(OutputStream stream) throws Exception { + public boolean serialize(OutputStream stream) throws IOException { /* String owner = "owner: "+getSqlObject().getOwner()+"\n"; stream.write(owner.getBytes(Charset.forName("UTF-8"))); @@ -59,7 +51,7 @@ public boolean serialize(OutputStream stream) throws Exception { } @Override - public IMetaObject deSerialize(InputStream stream) throws Exception { + public IMetaObject deSerialize(InputStream stream) { NameMeta nm = MetaObjectFactory.parseMetaName(getName()); /* sqlObject = new DBSQLObject(); @@ -83,12 +75,13 @@ public IMetaObject deSerialize(InputStream stream) throws Exception { public String getHash() { return sqlObject != null ? sqlObject.getHash() : EMPTY_HASH; } - public void setObjectOptionFromMap(Map map) throws ExceptionDBGit { - NameMeta nm = MetaObjectFactory.parseMetaName(getName()); - if (!map.containsKey(nm.getName())) { - throw new ExceptionDBGitObjectNotFound(DBGitLang.getInstance().getValue("errors", "meta", "notFound").withParams(getName())); - } - setSqlObject(map.get(nm.getName())); - } + +// public void setSqlObjectFromMap(Map map) throws ExceptionDBGit { +// NameMeta nm = MetaObjectFactory.parseMetaName(getName()); +// if (!map.containsKey(nm.getName())) { +// throw new ExceptionDBGitObjectNotFound(DBGitLang.getInstance().getValue("errors", "meta", "notFound").withParams(getName())); +// } +// setSqlObject(map.get(nm.getName())); +// } } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java index 4bd6c27..798696c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java @@ -11,10 +11,7 @@ import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.core.DBGitIndex; import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.dbobjects.DBConstraint; -import ru.fusionsoft.dbgit.dbobjects.DBIndex; -import ru.fusionsoft.dbgit.dbobjects.DBTable; -import ru.fusionsoft.dbgit.dbobjects.DBTableField; +import ru.fusionsoft.dbgit.dbobjects.*; import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.yaml.YamlOrder; @@ -25,17 +22,17 @@ */ public class MetaTable extends MetaBase { - @YamlOrder(1) + @YamlOrder(3) private DBTable table; - @YamlOrder(2) + @YamlOrder(4) //private IMapFields fields = new TreeMapFields(); private Map fields = new TreeMap<>(); - @YamlOrder(3) + @YamlOrder(5) private Map indexes = new TreeMap<>(); - @YamlOrder(4) + @YamlOrder(6) private Map constraints = new TreeMap<>(); public MetaTable() { @@ -67,7 +64,7 @@ public boolean serialize(OutputStream stream) throws IOException { } @Override - public IMetaObject deSerialize(InputStream stream) throws IOException { + public IMetaObject deSerialize(InputStream stream) { return yamlDeSerialize(stream); } @@ -157,24 +154,6 @@ public CalcHash addData(String str){ } -// if(this.getTable() != null && this.getTable().getName().contains("clients")){ -// ConsoleWriter.printlnRed(MessageFormat.format("-\t-\t-\t-\t-\t-\ntable = {0} ; {1}, \nfields({2}) = \n{3}\nindexes({4}) = \n{5}\nconstraints({6}) = \n{7}" -// ,this.getTable() != null ? this.getTable().getName() + " ; " + truncateHash(this.getTable().getHash()) : "noname" -// ,this.getTable() != null ? this.getTable().getOptions().getChildren().entrySet().stream().map(x->"\n\t\t" + x.getKey() + " : " + x.getValue().getData()).collect(Collectors.joining("")) : "null" -// ,fields.keySet().size() -// ,fields.values().stream() -// .map(x->"\t\t" + x.getName() + ";" + x.getDefaultValue()) -// .collect(Collectors.joining("\n")) -// ,indexes.keySet().size() -// ,indexes.values().stream() -// .map(x->"\t\t" + x.getName() + ";" + truncateHash(x.getHash())) -// .collect(Collectors.joining("\n")) -// ,constraints.keySet().size() -// ,constraints.values().stream() -// .map(x->"\t\t" + x.getName() + ";" + truncateHash(x.getHash())) -// .collect(Collectors.joining("\n")) -// )); -// } return ch.calcHashStr(); } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index 08b887d..1da10a1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -103,9 +103,7 @@ public void setTable(DBTable table) throws ExceptionDBGit { public void setName(String name) throws ExceptionDBGit { if (table == null) { NameMeta nm = MetaObjectFactory.parseMetaName(name); - table = new DBTable(); - table.setSchema(nm.getSchema()); - table.setName(nm.getName()); + table = new DBTable(nm.getName(), nm.getSchema()); } super.setName(name); @@ -313,7 +311,7 @@ public boolean loadPortionFromDB(int currentPortionIndex, int tryNumber) throws } catch (Exception e1) { // TODO Auto-generated catch block e1.printStackTrace(); - } + } if (e instanceof ExceptionDBGit) throw (ExceptionDBGit)e; throw new ExceptionDBGit(e); diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java index b2a2f52..16fd538 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/SortedListMetaObject.java @@ -28,17 +28,36 @@ public SortedListMetaObject(Collection fromCollection){ calculateImoCrossDependencies(); } + public Collection getCollection(){ + return collection; +} + public List sortFromDependencies() throws ExceptionDBGit { + if (listFromDependant == null) { + listFromDependant = createSortedList(false); + } + return listFromDependant; + + } + public List sortFromReferenced() throws ExceptionDBGit { + if (listFromFree == null) { + listFromFree = createSortedList(true); + } + return listFromFree; + } + private void calculateImoCrossDependencies(){ -// Timestamp timestampBefore = new Timestamp(System.currentTimeMillis()); for(DBGitMetaType metaType : Sets.newHashSet(DBGitMetaType.DBGitTable, DBGitMetaType.DbGitFunction)){ - List objectsOfType = collection.stream().filter(x->x.getType().equals(metaType) ).collect(Collectors.toList()); + List objectsOfType = collection.stream() + .filter( x->x.getType().equals(metaType) ) + .collect(Collectors.toList()); + + Map realNamesToMetaNames = objectsOfType.stream().collect(Collectors.toMap( - x-> x.getUnderlyingDbObject().getSchema() + "." + x.getUnderlyingDbObject().getName(), - IMetaObject::getName - ) - ); + x-> x.getUnderlyingDbObject().getSchema() + "." + x.getUnderlyingDbObject().getName(), + IMetaObject::getName + )); for(IMetaObject imo : objectsOfType){ if(imo.getType().equals(DBGitMetaType.DbGitFunction)){ @@ -52,20 +71,14 @@ private void calculateImoCrossDependencies(){ if(imo.getType().equals(DBGitMetaType.DBGitTable)){ DBTable dbTable = (DBTable) imo.getUnderlyingDbObject(); Set deps = realNamesToMetaNames.values().stream() - .filter( x -> dbTable.getDependencies().contains(x) /*&& !x.equals(imo.getName())*/ ) - .collect(Collectors.toSet()); - dbTable.setDependencies(deps); + .filter( x -> dbTable.getDependencies().contains(x) /*&& !x.equals(imo.getName())*/ ) + .collect(Collectors.toSet()); + dbTable.getDependencies().addAll(deps); } } } -// Timestamp timestampAfter = new Timestamp(System.currentTimeMillis()); -// long diff = timestampAfter.getTime() - timestampBefore.getTime(); -// ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "time").withParams(Long.toString(diff))); - } - public Collection getCollection(){ - return collection; } public List createSortedList(boolean isSortedFromFree) throws ExceptionDBGit { @@ -129,19 +142,6 @@ public List createSortedList(boolean isSortedFromFree) throws Excep return list; } - public List sortFromDependencies() throws ExceptionDBGit { - if (listFromDependant == null) { - listFromDependant = createSortedList(false); - } - return listFromDependant; - - } - public List sortFromReferenced() throws ExceptionDBGit { - if (listFromFree == null) { - listFromFree = createSortedList(true); - } - return listFromFree; - } public static Comparator imoTypeComparator = Comparator.comparing(x->x.getType().getPriority()); public static Comparator imoDependenceComparator = (o1, o2) -> { diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java index b630b9b..b964d5c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java @@ -266,8 +266,7 @@ public Map getTables(String schema) { while(rs.next()){ String nameTable = rs.getString("name"); - DBTable table = new DBTable(nameTable); - table.setSchema(schema); + DBTable table = new DBTable(nameTable, schema); rowToProperties(rs, table.getOptions()); listTable.put(nameTable, table); } @@ -296,8 +295,7 @@ public DBTable getTable(String schema, String name) { while(rs.next()){ String nameTable = rs.getString("tableName"); - table = new DBTable(nameTable); - table.setSchema(schema); + table = new DBTable(nameTable, schema); rowToProperties(rs, table.getOptions()); } return table; @@ -505,11 +503,14 @@ public Map getIndexesWithPks(String schema, String nameTable) { ResultSet rs = stmt.executeQuery(query); while(rs.next()){ - DBIndex index = new DBIndex(); - index.setName(rs.getString("indexName")); - index.setSchema(schema); + String name = rs.getString("indexName"); + String owner = rs.getString("owner"); + DBIndex index = new DBIndex(name, schema, owner); + rowToProperties(rs, index.getOptions()); indexes.put(index.getName(), index); + + } return indexes; @@ -586,10 +587,11 @@ public Map getConstraints(String schema, String nameTable) while (rs.next()) { - DBConstraint con = new DBConstraint(); - con.setName(rs.getString("constraintName")); - con.setConstraintType(rs.getString("constraintType")); - con.setSchema(schema); + String name = rs.getString("constraintName"); + String type = rs.getString("constraintType"); + String owner = "postgres"; + + DBConstraint con = new DBConstraint(name, schema, owner, type); rowToProperties(rs, con.getOptions()); constraints.put(con.getName(), con); } @@ -600,10 +602,8 @@ public Map getConstraints(String schema, String nameTable) Map indexes = getIndexesWithPks(schema, nameTable); indexes.values().removeIf(x->x.getOptions().getChildren().get("ispk").getData().equals("0")); for(DBIndex pki:indexes.values()){ - DBConstraint pkc = new DBConstraint(); - pkc.setName(pki.getName()); - pkc.setConstraintType(pki.getOptions().getChildren().get("typename").getData()); - pkc.setSchema(pki.getSchema()); + String constraintType = pki.getOptions().getChildren().get("typename").getData(); + DBConstraint pkc = new DBConstraint(pki.getName(),pki.getSchema(),pki.getOwner(), constraintType); pkc.setOptions(pki.getOptions()); constraints.put(pkc.getName(), pkc); } @@ -633,11 +633,12 @@ public Map getViews(String schema) { ResultSet rs = stmt.executeQuery(query); while(rs.next()){ - DBView view = new DBView(rs.getString("viewName")); - view.setSchema(rs.getString("schemaName")); - view.setOwner(rs.getString("ownerName")); + String name = rs.getString("viewName"); + String schemaName = rs.getString("schemaName"); + String owner = rs.getString("ownerName"); + DBView view = new DBView(name, schema, owner); rowToProperties(rs, view.getOptions()); - listView.put(rs.getString("viewName"), view); + listView.put(name, view); } return listView; }catch(Exception e) { @@ -688,14 +689,10 @@ public Map getProcedures(String schema) { while(rs.next()){ String name = rs.getString("procedureName"); String owner = rs.getString("owner"); - DBProcedure proc = new DBProcedure(name); - proc.setSchema(schema); - proc.setOwner(owner); - proc.setName(name); + DBProcedure proc = new DBProcedure(name, schema, owner); rowToProperties(rs,proc.getOptions()); listProcedure.put(name, proc); } - stmt.close(); }catch(Exception e) { throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); } @@ -719,10 +716,9 @@ public DBProcedure getProcedure(String schema, String name) { DBProcedure proc = null; while (rs.next()) { - proc = new DBProcedure(rs.getString("procedureName")); String owner = rs.getString("owner"); - proc.setSchema(schema); - proc.setOwner(owner); + String procedureName = rs.getString("procedureName"); + proc = new DBProcedure(procedureName, schema, owner); rowToProperties(rs,proc.getOptions()); } stmt.close(); @@ -750,9 +746,7 @@ public Map getFunctions(String schema) { while(rs.next()){ String name = rs.getString("functionName"); String owner = rs.getString("owner"); - DBFunction func = new DBFunction(name); - func.setSchema(schema); - func.setOwner(owner); + DBFunction func = new DBFunction(name, schema, owner); rowToProperties(rs,func.getOptions()); listFunction.put(name, func); @@ -777,10 +771,9 @@ public DBFunction getFunction(String schema, String name) { DBFunction func = null; ResultSet rs = stmt.executeQuery(query); while (rs.next()) { - func = new DBFunction(rs.getString("functionName")); + String functionName = rs.getString("functionName"); String owner = rs.getString("owner"); - func.setSchema(schema); - func.setOwner(owner); + func = new DBFunction(functionName, schema, owner); rowToProperties(rs,func.getOptions()); } return func; @@ -814,7 +807,7 @@ public Map getTriggers(String schema) { while(rs.next()){ String name = rs.getString("triggerName"); String owner = rs.getString("owner"); - DBTrigger trigger = new DBTrigger(name); + DBTrigger trigger = new DBTrigger(name, schema, owner); trigger.setSchema(schema); trigger.setOwner(owner); // -- what means owner? oracle/postgres or owner like database user/schema @@ -850,7 +843,7 @@ public DBTrigger getTrigger(String schema, String name) { while(rs.next()){ String tname = rs.getString("triggerName"); String owner = rs.getString("owner"); - trigger = new DBTrigger(tname); + trigger = new DBTrigger(tname, schema, owner); trigger.setSchema(schema); trigger.setOwner(owner); rowToProperties(rs, trigger.getOptions()); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java index 28e0c2e..fc11dc9 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java @@ -13,6 +13,7 @@ import java.util.Set; import java.util.concurrent.TimeUnit; +import org.apache.commons.lang3.exception.ExceptionUtils; import org.slf4j.Logger; import com.axiomalaska.jdbc.NamedParameterPreparedStatement; @@ -101,21 +102,20 @@ public IMapMetaObject loadCustomMetaObjects() { @Override public Map getSchemes() { + String query = + "select schema_name\r\n" + + "from information_schema.schemata"; + Map listScheme = new HashMap(); - try { - String query = "select schema_name\r\n" + - "from information_schema.schemata"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ String name = rs.getString("schema_name"); DBSchema scheme = new DBSchema(name); rowToProperties(rs, scheme.getOptions()); listScheme.put(name, scheme); } - stmt.close(); - }catch(Exception e) { + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "schemes").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "schemes").toString(), e); } @@ -132,25 +132,27 @@ public Map getTableSpaces() { @Override public Map getSequences(String schema) { Map sequences = new HashMap(); - try { - String query = "select column_name, table_name, column_type, extra from information_schema.columns" + - " where extra like '%auto_increment%' and table_schema='" + schema + "'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + + String query = + "select column_name, table_name, column_type, extra from information_schema.columns" + + " where extra like '%auto_increment%' and table_schema='" + schema + "'"; + + try(Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + String valueQuery = + "select coalesce(max(" + rs.getString("column_name") + "), 0) as nextval" + + " from " + schema + ".`" + rs.getString("table_name") + "`"; + while(rs.next()) { - String name = rs.getString("column_name"); - DBSequence seq = new DBSequence(name); - Statement stmtValue = connect.createStatement(); - ResultSet rsValue = stmtValue.executeQuery("select coalesce(max(" + rs.getString("column_name") + "), 0) as nextval" + - " from " + schema + ".`" + rs.getString("table_name") + "`"); - rsValue.next(); - seq.setSchema(schema); - seq.setValue(rsValue.getLong("nextval")); - sequences.put(name, seq); - stmtValue.close(); + + try(Statement stmtValue = connect.createStatement(); ResultSet rsValue = stmtValue.executeQuery(valueQuery)){ + rsValue.next(); + String name = rs.getString("column_name"); + Long value = rsValue.getLong("nextval"); + DBSequence seq = new DBSequence(name, schema, value); + sequences.put(name, seq); + } + } - stmt.close(); } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "seq").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "seq").toString(), e); @@ -160,134 +162,125 @@ public Map getSequences(String schema) { @Override public DBSequence getSequence(String schema, String name) { + String query = + "select column_name, table_name, column_type, extra from information_schema.columns" + + " where extra like '%auto_increment%' and table_schema='" + schema + "' and column_name='" + name + "'"; + DBSequence seq = null; - try { - String query = "select column_name, table_name, column_type, extra from information_schema.columns" + - " where extra like '%auto_increment%' and table_schema='" + schema + "' and column_name='" + name + "'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + if(rs.next()) { - seq = new DBSequence(name); - Statement stmtValue = connect.createStatement(); - ResultSet rsValue = stmtValue.executeQuery("select coalesce(max(" + rs.getString("column_name") + "), 0) as nextval" + - " from " + schema + ".`" + rs.getString("table_name") + "`"); - rsValue.next(); - seq.setSchema(schema); - seq.setValue(rsValue.getLong("nextval")); - stmtValue.close(); + + String valueQuery = + "select coalesce(max(" + rs.getString("column_name") + "), 0) as nextval" + + " from " + schema + ".`" + rs.getString("table_name") + "`"; + + try(Statement stmtValue = connect.createStatement(); ResultSet rsValue = stmtValue.executeQuery(valueQuery)){ + rsValue.next(); + Long value = rsValue.getLong("nextval"); + seq = new DBSequence(name, schema, value); + } } - stmt.close(); + } catch (Exception e) { logger.error(lang.getValue("errors", "adapter", "seq").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "seq").toString(), e); } + return seq; } @Override public Map getTables(String schema) { Map listTable = new HashMap(); - try { - String query = "SELECT T.TABLE_NAME, T.TABLE_SCHEMA " + - "FROM information_schema.tables T WHERE TABLE_SCHEMA = '" + schema + "' and TABLE_TYPE = 'BASE TABLE'"; - Connection connect = getConnection(); - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - + String query = + "SELECT T.TABLE_NAME, T.TABLE_SCHEMA " + + "FROM information_schema.tables T WHERE TABLE_SCHEMA = '" + schema + "' and TABLE_TYPE = 'BASE TABLE'"; + + try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ String nameTable = rs.getString("TABLE_NAME"); - DBTable table = new DBTable(nameTable); - table.setSchema(schema); + //TODO retrieve table comment + DBTable table = new DBTable(nameTable, schema, null); rowToProperties(rs, table.getOptions()); - - Statement stmtDdl = connect.createStatement(); - ResultSet rsDdl = stmtDdl.executeQuery("show create table " + schema + ".`" + nameTable + "`"); - rsDdl.next(); - - table.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); - - listTable.put(nameTable, table); - - stmtDdl.close(); - rsDdl.close(); + + String ddlQuery = "show create table " + schema + ".`" + nameTable + "`"; + try(Statement stmtDdl = connect.createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ + rsDdl.next(); + table.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); + listTable.put(nameTable, table); + + } } - rs.close(); - stmt.close(); - }catch(Exception e) { + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); } + return listTable; } @Override public DBTable getTable(String schema, String name) { - try { - String query = "SELECT T.TABLE_NAME, T.TABLE_SCHEMA " + - "FROM information_schema.tables T WHERE TABLE_SCHEMA = '" + schema + "' AND T.TABLE_NAME = '" + name + "'"; - Connection connect = getConnection(); - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "SELECT T.TABLE_NAME, T.TABLE_SCHEMA FROM information_schema.tables T" + + " WHERE TABLE_SCHEMA = '" + schema + "'" + + " AND T.TABLE_NAME = '" + name + "'"; + + DBTable table = null; + + try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);){ - DBTable table = null; - while(rs.next()) { String nameTable = rs.getString("TABLE_NAME"); - table = new DBTable(nameTable); - table.setSchema(schema); - - Statement stmtDdl = connect.createStatement(); - ResultSet rsDdl = stmtDdl.executeQuery("show create table " + schema + ".`" + nameTable + "`"); - rsDdl.next(); - table.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); - rowToProperties(rs, table.getOptions()); - stmtDdl.close(); - rsDdl.close(); + String ddlQuery = "show create table " + schema + ".`" + nameTable + "`"; + table = new DBTable(nameTable, schema, null); + + try(Statement stmtDdl = connect.createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ + rsDdl.next(); + table.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); + rowToProperties(rs, table.getOptions()); + } } - rs.close(); - stmt.close(); - - return table; - - }catch(Exception e) { + + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); } + + return table; } @Override public Map getTableFields(String schema, String nameTable) { - try { - Map listField = new HashMap(); - - String query = - "SELECT distinct col.column_name,col.is_nullable,col.data_type,col.character_maximum_length, tc.constraint_name, " + - "case\r\n" + - " when lower(data_type) in ('tinyint', 'smallint', 'mediumint', 'int', 'bigint', 'float', 'double', 'decimal') then 'number' \r\n" + - " when lower(data_type) in ('tinytext', 'text', 'char', 'mediumtext', 'longtext', 'varchar') then 'string'\r\n" + - " when lower(data_type) in ('datetime', 'timestamp', 'date') then 'date'\r\n" + - " when lower(data_type) in ('boolean') then 'boolean'\r\n" + - " when lower(data_type) in ('blob', 'mediumblob', 'longblob', 'binary', 'varbinary') then 'binary'" + - " else 'native'\r\n" + - " end tp, " + - " case when lower(data_type) in ('char', 'character') then true else false end fixed, " + - "col.* FROM " + - "information_schema.columns col " + - "left join information_schema.key_column_usage kc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and col.column_name=kc.column_name " + - "left join information_schema.table_constraints tc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and kc.constraint_name = tc.constraint_name and tc.constraint_type = 'PRIMARY KEY' " + - "where col.table_schema = :schema and col.table_name = :table " + - "order by col.column_name "; - Connection connect = getConnection(); - - NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); + + Map listField = new HashMap(); + + String query = + "SELECT distinct col.column_name,col.is_nullable,col.data_type,col.character_maximum_length, tc.constraint_name, " + + "case\r\n" + + " when lower(data_type) in ('tinyint', 'smallint', 'mediumint', 'int', 'bigint', 'float', 'double', 'decimal') then 'number' \r\n" + + " when lower(data_type) in ('tinytext', 'text', 'char', 'mediumtext', 'longtext', 'varchar') then 'string'\r\n" + + " when lower(data_type) in ('datetime', 'timestamp', 'date') then 'date'\r\n" + + " when lower(data_type) in ('boolean') then 'boolean'\r\n" + + " when lower(data_type) in ('blob', 'mediumblob', 'longblob', 'binary', 'varbinary') then 'binary'" + + " else 'native'\r\n" + + " end tp, " + + " case when lower(data_type) in ('char', 'character') then true else false end fixed, " + + "col.* FROM " + + "information_schema.columns col " + + "left join information_schema.key_column_usage kc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and col.column_name=kc.column_name " + + "left join information_schema.table_constraints tc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and kc.constraint_name = tc.constraint_name and tc.constraint_type = 'PRIMARY KEY' " + + "where col.table_schema = :schema and col.table_name = :table " + + "order by col.column_name "; + + try (NamedParameterPreparedStatement stmt = getParamStatement(query, getConnection()); ResultSet rs = stmt.executeQuery();){ + stmt.setString("schema", schema); stmt.setString("table", nameTable); - ResultSet rs = stmt.executeQuery(); - while(rs.next()){ + while(rs.next()){ DBTableField field = new DBTableField(); field.setName(rs.getString("column_name").toLowerCase()); if (rs.getString("constraint_name") != null) { @@ -307,44 +300,47 @@ public Map getTableFields(String schema, String nameTable) stmt.close(); return listField; - }catch(Exception e) { + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); } } + + @Override public Map getIndexes(String schema, String nameTable) { - try { - Map indexes = new HashMap<>(); - String query = "select TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE, GROUP_CONCAT(COLUMN_NAME separator '`, `') as FIELDS " - + "from INFORMATION_SCHEMA.STATISTICS where TABLE_SCHEMA = '" + schema + "' and INDEX_NAME != 'PRIMARY' " - + "group by TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE order by TABLE_NAME, INDEX_NAME;"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + Map indexes = new HashMap<>(); + + String query = "select TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE, GROUP_CONCAT(COLUMN_NAME separator '`, `') as FIELDS " + + "from INFORMATION_SCHEMA.STATISTICS where TABLE_SCHEMA = '" + schema + "' and INDEX_NAME != 'PRIMARY' " + + "group by TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE order by TABLE_NAME, INDEX_NAME;"; + + try(Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()) { - DBIndex index = new DBIndex(rs.getString("INDEX_NAME")); - index.setSchema(schema); - index.setOwner(schema); + + //TODO find real owner + DBIndex index = new DBIndex(rs.getString("INDEX_NAME"), schema, schema); rowToProperties(rs, index.getOptions()); - String ddl = "create " + (rs.getInt("NON_UNIQUE") == 1 ? "" : "unique ") - + "index `" + rs.getString("INDEX_NAME") - + "` using " + rs.getString("INDEX_TYPE") - + " on " + schema + ".`" + rs.getString("TABLE_NAME") + "`" - + "(`" + rs.getString("FIELDS") + "`)"; + String ddl = + "create " + (rs.getInt("NON_UNIQUE") == 1 ? "" : "unique ") + + "index `" + rs.getString("INDEX_NAME") + + "` using " + rs.getString("INDEX_TYPE") + + " on " + schema + ".`" + rs.getString("TABLE_NAME") + "`" + + "(`" + rs.getString("FIELDS") + "`)"; index.getOptions().addChild("ddl", cleanString(ddl)); indexes.put(rs.getString("INDEX_NAME"), index); } - stmt.close(); - return indexes; + } catch(Exception e) { logger.error(e.getMessage()); System.out.println(e.getMessage()); throw new ExceptionDBGitRunTime(e.getMessage()); } + + return indexes; } @Override @@ -356,54 +352,52 @@ public Map getConstraints(String schema, String nameTable) @Override public Map getViews(String schema) { Map listView = new HashMap(); - try { - String query = "show full tables in " + schema + " where TABLE_TYPE like 'VIEW'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = "show full tables in " + schema + " where TABLE_TYPE like 'VIEW'"; + + try (Statement stmt = getConnection().createStatement();ResultSet rs = stmt.executeQuery(query);) { + + String name = rs.getString(1); + String ddlQuery = "show create view " + schema + "." + name; while(rs.next()){ - DBView view = new DBView(rs.getString(1)); - view.setSchema(schema); - view.setOwner(schema); + //TODO try find real owner + DBView view = new DBView(name, schema, schema); rowToProperties(rs, view.getOptions()); - Statement stmtDdl = connect.createStatement(); - ResultSet rsDdl = stmtDdl.executeQuery("show create view " + schema + "." + rs.getString(1)); - rsDdl.next(); - - view.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); - listView.put(rs.getString(1), view); - - stmtDdl.close(); - rsDdl.close(); + try(Statement stmtDdl = getConnection().createStatement();ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ + rsDdl.next(); + view.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); + listView.put(name, view); + } } - stmt.close(); - return listView; + } catch(Exception e) { logger.error(e.getMessage()); System.out.println(e.getMessage()); throw new ExceptionDBGitRunTime(e.getMessage()); } + + return listView; + } @Override public DBView getView(String schema, String name) { - DBView view = new DBView(name); - view.setSchema(schema); - view.setOwner(schema); - try { - Statement stmtDdl = connect.createStatement(); - ResultSet rsDdl = stmtDdl.executeQuery("show create view " + schema + ".`" + name + "`"); - if(rsDdl.next()) + //TODO find real owner + String query = "show create view " + schema + ".`" + name + "`"; + DBView view = new DBView(name, schema, schema); + + try (Statement stmtDdl = getConnection().createStatement();ResultSet rsDdl = stmtDdl.executeQuery(query);){ + + if(rsDdl.next()) { view.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); - stmtDdl.close(); - rsDdl.close(); - return view; - }catch(Exception e) { + } + + } catch(Exception e) { logger.error(e.getMessage()); throw new ExceptionDBGitRunTime(e.getMessage()); } - + + return view; } @Override @@ -433,141 +427,159 @@ public DBProcedure getProcedure(String schema, String name) { @Override public Map getFunctions(String schema) { Map listFunction = new HashMap(); - try { - String query = "SELECT R.routine_schema as \"schema\", R.definer as \"rolname\", R.specific_name as \"name\"," + - "group_concat(concat(P.parameter_name, \" \", P.data_type)) as \"arguments\", R.routine_definition as \"ddl\"\r\n" + - "FROM information_schema.routines as R, information_schema.parameters as P\r\n" + - "WHERE P.parameter_mode='IN' and P.routine_type=R.routine_type and P.specific_schema=R.routine_schema and\r\n" + - "P.specific_name=R.specific_name and R.routine_type='FUNCTION' and R.routine_schema='" + schema + "' GROUP BY R.specific_name,1,2,5,P.ordinal_position ORDER BY P.ordinal_position"; - Statement stmt = getConnection().createStatement(); - ResultSet rs = stmt.executeQuery(query); + + String query = + "SELECT R.routine_schema as \"schema\", R.definer as \"rolname\", R.specific_name as \"name\"," + + "group_concat(concat(P.parameter_name, \" \", P.data_type)) as \"arguments\", R.routine_definition as \"ddl\"\r\n" + + "FROM information_schema.routines as R, information_schema.parameters as P\r\n" + + "WHERE P.parameter_mode='IN' and P.routine_type=R.routine_type and P.specific_schema=R.routine_schema and\r\n" + + "P.specific_name=R.specific_name and R.routine_type='FUNCTION' and R.routine_schema='" + schema + "'" + + " GROUP BY R.specific_name,1,2,5,P.ordinal_position ORDER BY P.ordinal_position"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()) { String name = rs.getString("name"); String owner = rs.getString("rolname"); - String args = rs.getString("arguments"); - DBFunction func = new DBFunction(name); - func.setSchema(schema); - func.setOwner(owner); + + DBFunction func = new DBFunction(name, schema, owner); rowToProperties(rs, func.getOptions()); + //String args = rs.getString("arguments"); //func.setArguments(args); listFunction.put(name, func); } - stmt.close(); + } catch(Exception e) { throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); } + return listFunction; } @Override public DBFunction getFunction(String schema, String name) { - DBFunction function = new DBFunction(name); - try { - String query = "SELECT R.routine_schema as \"schema\", R.definer as \"rolname\", R.specific_name as \"name\"," + - "group_concat(concat(P.parameter_name, \" \", P.data_type)) as \"arguments\", R.routine_definition as \"ddl\"\r\n" + - "FROM information_schema.routines as R, information_schema.parameters as P\r\n" + - "WHERE P.parameter_mode='IN' and P.routine_type=R.routine_type and P.specific_schema=R.routine_schema and\r\n" + - "P.specific_name=R.specific_name and R.routine_type='FUNCTION' and R.routine_schema='" + schema + "' and R.specific_name='" + name + "'\r\n" + - "GROUP BY R.specific_name,1,2,5,P.ordinal_position ORDER BY P.ordinal_position"; - Statement stmt = getConnection().createStatement(); - ResultSet rs = stmt.executeQuery(query); + DBFunction function = null; + + String query = + "SELECT R.routine_schema as \"schema\", R.definer as \"rolname\", R.specific_name as \"name\"," + + "group_concat(concat(P.parameter_name, \" \", P.data_type)) as \"arguments\", R.routine_definition as \"ddl\"\r\n" + + "FROM information_schema.routines as R, information_schema.parameters as P\r\n" + + "WHERE P.parameter_mode='IN' and P.routine_type=R.routine_type and P.specific_schema=R.routine_schema and\r\n" + + "P.specific_name=R.specific_name and R.routine_type='FUNCTION' and R.routine_schema='" + schema + "'" + + " and R.specific_name='" + name + "'\r\n" + + "GROUP BY R.specific_name,1,2,5,P.ordinal_position ORDER BY P.ordinal_position"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + if(rs.next()) { String owner = rs.getString("rolname"); - String args = rs.getString("arguments"); - function.setSchema(schema); - function.setOwner(owner); + + function = new DBFunction(name, schema, owner); rowToProperties(rs, function.getOptions()); + //String args = rs.getString("arguments"); //function.setArguments(args); } - stmt.close(); - } catch(Exception e) { + + } catch (Exception e) { throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); } + return function; } @Override public Map getTriggers(String schema) { + Map listTrigger = new HashMap(); - try { - String query = "show triggers in " + schema; - - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = "show triggers in " + schema; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while(rs.next()){ + //TODO find real owner String name = rs.getString(1); - DBTrigger trigger = new DBTrigger(name); - trigger.setSchema(schema); - trigger.setOwner(schema); - - Statement stmtDdl = connect.createStatement(); - ResultSet rsDdl = stmtDdl.executeQuery("show create trigger " + schema + "." + rs.getString(1)); - rsDdl.next(); - - trigger.getOptions().addChild("ddl", cleanString(rsDdl.getString(3))); - - stmtDdl.close(); - rsDdl.close(); - - rowToProperties(rs, trigger.getOptions()); + DBTrigger trigger = new DBTrigger(name, schema, schema); + String ddlQuery = "show create trigger " + schema + "." + name; + + try(Statement stmtDdl = getConnection().createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ + rsDdl.next(); + trigger.setSql(rsDdl.getString(3)); + rowToProperties(rs, trigger.getOptions()); + + } + listTrigger.put(name, trigger); } - stmt.close(); - return listTrigger; - }catch(Exception e) { - throw new ExceptionDBGitRunTime(e); + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(e); } + + return listTrigger; } @Override public DBTrigger getTrigger(String schema, String name) { - DBTrigger trigger = new DBTrigger(name); - try { - trigger.setSchema(schema); - trigger.setOwner(schema); - - Statement stmtDdl = connect.createStatement(); - ResultSet rsDdl = stmtDdl.executeQuery("show create trigger " + schema + "." + name); + + DBTrigger trigger = null; + String query = "show create trigger " + schema + "." + name; + + try (Statement stmtDdl = getConnection().createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(query);) { + rsDdl.next(); - + + //TODO find real owner + trigger = new DBTrigger(name, schema, schema); trigger.getOptions().addChild("ddl", cleanString(rsDdl.getString(3))); - - stmtDdl.close(); - rsDdl.close(); - - return trigger; - - }catch(Exception e) { - throw new ExceptionDBGitRunTime(e); + + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(e); } + + return trigger; } @Override public DBTableData getTableData(String schema, String nameTable) { + DBTableData data = new DBTableData(); String tableName = schema + ".`" + nameTable + "`"; + String dataQuery = "select * from " + tableName; + try { - DBTableData data = new DBTableData(); - - int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH)); - - if (DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true))) { - Statement st = getConnection().createStatement(); - String query = "select COALESCE(count(*), 0) kolvo from ( select 1 from "+ - tableName + " limit " + (maxRowsCount + 1) + " ) tbl"; - ResultSet rs = st.executeQuery(query); - rs.next(); - if (rs.getInt("kolvo") > maxRowsCount) { - data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); - return data; + + int maxRowsCount = DBGitConfig.getInstance().getInteger( + "core", "MAX_ROW_COUNT_FETCH", + DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH) + ); + + boolean toLimitFetch = DBGitConfig.getInstance().getBoolean( + "core", "LIMIT_FETCH", + DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true) + ); + + String query = + "select COALESCE(count(*), 0) kolvo" + + " from ( select 1 from " + tableName + " limit " + (maxRowsCount + 1) + " ) tbl"; + + + if (toLimitFetch) { + + try (Statement st = getConnection().createStatement(); ResultSet rs = st.executeQuery(query);){ + rs.next(); + + if (rs.getInt("kolvo") > maxRowsCount) { + data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); + } else { + ResultSet dataResultSet = st.executeQuery(dataQuery); + data.setResultSet(dataResultSet); + } + + } - - rs = st.executeQuery("select * from "+tableName); - data.setResultSet(rs); - return data; + } - return data; } catch(Exception e) { throw new ExceptionDBGitRunTime(e); } @@ -577,10 +589,10 @@ public DBTableData getTableData(String schema, String nameTable) { @Override public Map getUsers() { Map users = new HashMap(); - try { - String query = "select User, authentication_string from mysql.user"; - Statement stmt = getConnection().createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = "select User, authentication_string from mysql.user"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()) { String name = rs.getString(1); String password = rs.getString(2); @@ -589,11 +601,12 @@ public Map getUsers() { DBUser user = new DBUser(name, options); users.put(name, user); } - stmt.close(); - }catch(Exception e) { + + } catch(Exception e) { logger.error(e.getMessage()); throw new ExceptionDBGitRunTime(e.getMessage()); } + return users; } @@ -637,21 +650,19 @@ public String getDbVersion() { @Override public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit { - try { - Statement st = connect.createStatement(); - ResultSet rs = st.executeQuery("select count(*) cnt from information_schema.schemata where upper(schema_name) = '" + - schemaName.toUpperCase() + "'"); + String query = + "select count(*) cnt from information_schema.schemata where upper(schema_name) = '" + + schemaName.toUpperCase() + "'"; + + try (Statement st = connect.createStatement(); ResultSet rs = st.executeQuery(query);) { rs.next(); - if (rs.getInt("cnt") == 0) { - StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql()); - stLog.execute("create schema " + schemaName); + if (rs.getInt("cnt") == 0) + try(StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql());) { - stLog.close(); + stLog.execute("create schema " + schemaName); } - rs.close(); - st.close(); } catch (SQLException e) { throw new ExceptionDBGit(lang.getValue("errors", "adapter", "createSchema") + ": " + e.getLocalizedMessage()); } @@ -677,7 +688,7 @@ protected String getFieldType(ResultSet rs) { } return type.toString(); - }catch(Exception e) { + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); } @@ -752,6 +763,10 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port } } + private NamedParameterPreparedStatement getParamStatement(String query, Connection connect) throws SQLException { + return NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); + } + static { reservedWords = new HashSet<>(); reservedWords.add("ACCESSIBLE"); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java index 9efd6fa..699e1a4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableMySql.java @@ -64,14 +64,14 @@ public void removeMetaObject(IMetaObject obj) throws Exception { public void restoreTableMySql(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { + + try (StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql());){ if (obj instanceof MetaTable) { MetaTable restoreTable = (MetaTable) obj; String schema = getPhisicalSchema(restoreTable.getTable().getSchema().toLowerCase()); schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); String tblName = schema + ".`" + restoreTable.getTable().getName() + "`"; - ConsoleWriter.detailsPrintLn(lang.getValue("general", "restore", "createTable"), 3); + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "createTable"), messageLevel); StringBuilder pk = new StringBuilder(); String ddl = "CREATE TABLE IF NOT EXISTS " + tblName + " (" + restoreTable @@ -104,8 +104,6 @@ public void restoreTableMySql(IMetaObject obj) throws Exception { } } catch (Exception e) { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); - } finally { - st.close(); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java index a1653ca..c908fad 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java @@ -63,7 +63,6 @@ public class DBAdapterOracle extends DBAdapter { private FactoryDbConvertAdapterOracle convertFactory = new FactoryDbConvertAdapterOracle(); private FactoryDBBackupAdapterOracle backupFactory = new FactoryDBBackupAdapterOracle(); - private String s; @Override public IFactoryDBAdapterRestoteMetaData getFactoryRestore() { @@ -90,23 +89,22 @@ public IMapMetaObject loadCustomMetaObjects() { @Override public Map getSchemes() { Map listScheme = new HashMap(); - try { - String query = "SELECT DISTINCT OWNER\n" + - "FROM DBA_OBJECTS WHERE OWNER != 'PUBLIC' AND OWNER != 'SYSTEM'\n" + - "AND OWNER != 'SYS' AND OWNER != 'APPQOSSYS' AND OWNER != 'OUTLN' \n" + - "AND OWNER != 'DIP' AND OWNER != 'DBSNMP' AND OWNER != 'ORACLE_OCM'\n" + - "ORDER BY OWNER"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "SELECT DISTINCT OWNER\n" + + "FROM DBA_OBJECTS WHERE OWNER != 'PUBLIC' AND OWNER != 'SYSTEM'\n" + + "AND OWNER != 'SYS' AND OWNER != 'APPQOSSYS' AND OWNER != 'OUTLN' \n" + + "AND OWNER != 'DIP' AND OWNER != 'DBSNMP' AND OWNER != 'ORACLE_OCM'\n" + + "ORDER BY OWNER"; + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ String name = rs.getString("OWNER"); DBSchema scheme = new DBSchema(name); rowToProperties(rs, scheme.getOptions()); listScheme.put(name, scheme); - } - stmt.close(); - }catch(Exception e) { + } + + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "schemes").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "schemes").toString(), e); } @@ -116,215 +114,207 @@ public Map getSchemes() { @Override public Map getTableSpaces() { + Map listTableSpace = new HashMap(); - try { - String query = "SELECT owner,\n" + - " segment_name,\n" + - " partition_name,\n" + - " segment_type,\n" + - " bytes \n" + - " FROM dba_segments \n" + - " WHERE OWNER != 'PUBLIC' AND OWNER != 'SYSTEM'\n" + - "AND OWNER != 'SYS' AND OWNER != 'APPQOSSYS' AND OWNER != 'OUTLN' \n" + - "AND OWNER != 'DIP' AND OWNER != 'DBSNMP' AND OWNER != 'ORACLE_OCM' and segment_name not like 'SYS%'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "SELECT owner,\n" + + " segment_name,\n" + + " partition_name,\n" + + " segment_type,\n" + + " bytes \n" + + " FROM dba_segments \n" + + " WHERE OWNER != 'PUBLIC' AND OWNER != 'SYSTEM'\n" + + "AND OWNER != 'SYS' AND OWNER != 'APPQOSSYS' AND OWNER != 'OUTLN' \n" + + "AND OWNER != 'DIP' AND OWNER != 'DBSNMP' AND OWNER != 'ORACLE_OCM' and segment_name not like 'SYS%'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ String name = rs.getString("segment_name"); DBTableSpace dbTableSpace = new DBTableSpace(name); rowToProperties(rs, dbTableSpace.getOptions()); listTableSpace.put(name, dbTableSpace); - } - stmt.close(); - }catch(Exception e) { + } + + } catch(Exception e) { logger.error(e.getMessage()); throw new ExceptionDBGitRunTime(e); } + return listTableSpace; } @Override public Map getSequences(String schema) { Map listSequence = new HashMap(); - try { - Connection connect = getConnection(); - //variant 1 from DBA_OBJECTS - /*String query = - "SELECT ROWNUM AS NUM, OWNER, OBJECT_NAME, SUBOBJECT_NAME, OBJECT_TYPE, STATUS,\n" + - "(select dbms_metadata.get_ddl('SEQUENCE', O.OBJECT_NAME) AS DDL from dual) AS DDL\n" + - "FROM DBA_OBJECTS O WHERE OBJECT_TYPE = 'SEQUENCE' AND OWNER = :schema";*/ - - //variant 2 from DBA_SEQUENCES - String query = - "SELECT S.SEQUENCE_NAME, (SELECT dbms_metadata.get_ddl('SEQUENCE', S.SEQUENCE_NAME, S.SEQUENCE_OWNER) from dual) AS DDL,\n" + - "order_flag, increment_by, last_number, min_value, max_value, cache_size \n" + - "FROM DBA_SEQUENCES S WHERE S.SEQUENCE_OWNER = '" + schema + "'"; - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + + //variant 1 from DBA_OBJECTS + /*String query = + "SELECT ROWNUM AS NUM, OWNER, OBJECT_NAME, SUBOBJECT_NAME, OBJECT_TYPE, STATUS,\n" + + "(select dbms_metadata.get_ddl('SEQUENCE', O.OBJECT_NAME) AS DDL from dual) AS DDL\n" + + "FROM DBA_OBJECTS O WHERE OBJECT_TYPE = 'SEQUENCE' AND OWNER = :schema";*/ + + //variant 2 from DBA_SEQUENCES + String query = + "SELECT S.SEQUENCE_NAME, (SELECT dbms_metadata.get_ddl('SEQUENCE', S.SEQUENCE_NAME, S.SEQUENCE_OWNER) from dual) AS DDL,\n" + + "order_flag, increment_by, last_number, min_value, max_value, cache_size \n" + + "FROM DBA_SEQUENCES S WHERE S.SEQUENCE_OWNER = '" + schema + "'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ String nameSeq = rs.getString("SEQUENCE_NAME"); - DBSequence sequence = new DBSequence(); - sequence.setName(nameSeq); - sequence.setSchema(schema); - sequence.setValue(0L); + //TODO find real sequence value + DBSequence sequence = new DBSequence(nameSeq, schema, 0L); rowToProperties(rs, sequence.getOptions()); listSequence.put(nameSeq, sequence); } - stmt.close(); - }catch(Exception e) { + + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "sequences").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "sequences").toString(), e); } + return listSequence; } @Override public DBSequence getSequence(String schema, String name) { - try { - Connection connect = getConnection(); - String query = - "SELECT S.SEQUENCE_NAME, (SELECT dbms_metadata.get_ddl('SEQUENCE', S.SEQUENCE_NAME, S.SEQUENCE_OWNER) from dual) AS DDL, \n" + - "order_flag, increment_by, last_number, min_value, max_value, cache_size \n" + - "FROM DBA_SEQUENCES S WHERE S.SEQUENCE_OWNER = '" + schema + "' AND S.SEQUENCE_NAME = '" + name + "'"; - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - - DBSequence sequence = null; + DBSequence sequence = null; + + String query = + "SELECT S.SEQUENCE_NAME, (SELECT dbms_metadata.get_ddl('SEQUENCE', S.SEQUENCE_NAME, S.SEQUENCE_OWNER) from dual) AS DDL, \n" + + "order_flag, increment_by, last_number, min_value, max_value, cache_size \n" + + "FROM DBA_SEQUENCES S WHERE S.SEQUENCE_OWNER = '" + schema + "' AND S.SEQUENCE_NAME = '" + name + "'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while (rs.next()) { String nameSeq = rs.getString("SEQUENCE_NAME"); - sequence = new DBSequence(); - sequence.setName(nameSeq); - sequence.setSchema(schema); - sequence.setValue(0L); + + //TODO find real sequence value + sequence = new DBSequence(nameSeq, schema, 0L); rowToProperties(rs, sequence.getOptions()); } - stmt.close(); - return sequence; - }catch(Exception e) { + + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "sequences").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "sequences").toString(), e); } + + return sequence; } @Override public Map getTables(String schema) { Map listTable = new HashMap(); - try { - String query = "SELECT T.TABLE_NAME, T.OWNER, (SELECT dbms_metadata.get_ddl('TABLE', T.TABLE_NAME, T.OWNER) from dual) AS DDL\n" + - "FROM DBA_TABLES T WHERE upper(OWNER) = upper('" + schema + "') and nested = 'NO' and (iot_type <> 'IOT_OVERFLOW' or iot_type is null)"; - Connection connect = getConnection(); - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - + + String query = + "SELECT T.TABLE_NAME, T.OWNER, (SELECT dbms_metadata.get_ddl('TABLE', T.TABLE_NAME, T.OWNER) from dual) AS DDL\n" + + "FROM DBA_TABLES T WHERE upper(OWNER) = upper('" + schema + "') and nested = 'NO' and (iot_type <> 'IOT_OVERFLOW' or iot_type is null)"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while(rs.next()){ String nameTable = rs.getString("TABLE_NAME"); - DBTable table = new DBTable(nameTable); - table.setSchema(schema); + DBTable table = new DBTable(nameTable, schema); rowToProperties(rs, table.getOptions()); listTable.put(nameTable, table); } - stmt.close(); - }catch(Exception e) { + + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); } + return listTable; } @Override public DBTable getTable(String schema, String name) { - try { - String query = "SELECT T.TABLE_NAME, T.OWNER, (SELECT dbms_metadata.get_ddl('TABLE', T.TABLE_NAME, T.OWNER) from dual) AS DDL\n" + - "FROM DBA_TABLES T WHERE upper(T.OWNER) = upper('" + schema + "') AND upper(T.TABLE_NAME) = upper('" + name + "')"; - Connection connect = getConnection(); - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + DBTable table = null; + + String query = + "SELECT T.TABLE_NAME, T.OWNER, (SELECT dbms_metadata.get_ddl('TABLE', T.TABLE_NAME, T.OWNER) from dual) AS DDL\n" + + "FROM DBA_TABLES T WHERE upper(T.OWNER) = upper('" + schema + "') AND upper(T.TABLE_NAME) = upper('" + name + "')"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - DBTable table = null; - while(rs.next()) { String nameTable = rs.getString("TABLE_NAME"); - table = new DBTable(nameTable); - table.setSchema(schema); + table = new DBTable(nameTable, schema); rowToProperties(rs, table.getOptions()); } - - stmt.close(); - return table; - - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); + + } catch(Exception e) { + logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); } + + return table; } @Override public Map getTableFields(String schema, String nameTable) { - try { - Map listField = new HashMap(); - - String query1 = - "SELECT column_name FROM all_constraints cons, all_cons_columns cols\n"+ - "WHERE upper(cols.table_name) = upper('" + nameTable + "')\n"+ - "AND cons.constraint_type = 'P'\n" + - "AND cons.constraint_name = cols.constraint_name\n" + - "AND cons.owner = cols.owner"; - Connection connect = getConnection(); - - Statement stmt = connect.createStatement(); - ResultSet rs1 = stmt.executeQuery(query1); - - String s = ""; - - while (rs1.next()) - s = rs1.getString("COLUMN_NAME").toLowerCase(); - - String query = - "SELECT case \r\n" + - " when lower(data_type) in ('number', 'numeric', 'dec', 'decimal', 'pls_integer') then 'number'\r\n" + - " when lower(data_type) in ('varchar2', 'varchar', 'char', 'nchar', 'nvarchar2') then 'string'\r\n" + - " when substr(lower(data_type), 1, instr(data_type, '(') - 1) in ('date', 'timestamp') then 'date'\r\n" + - " when lower(data_type) in ('date', 'timestamp') then 'date'\r\n" + - " when lower(data_type) in ('clob') then 'text'\r\n" + - " when lower(data_type) in ('blob') then 'binary'" + - " else 'native'\r\n" + - " end type, " + - " case when lower(data_type) in ('char', 'nchar') then 1 else 0 end fixed, " + - " ROWNUM AS NUM, TC.* FROM DBA_TAB_COLS TC \n" + - "WHERE lower(table_name) = lower('" + nameTable + "') AND lower(OWNER) = lower('" + schema + "') ORDER BY column_id"; - - ResultSet rs = stmt.executeQuery(query); - while(rs.next()){ + Map listField = new HashMap(); + + String pkNameQuery = + "SELECT column_name FROM all_constraints cons, all_cons_columns cols\n"+ + "WHERE upper(cols.table_name) = upper('" + nameTable + "')\n"+ + "AND cons.constraint_type = 'P'\n" + + "AND cons.constraint_name = cols.constraint_name\n" + + "AND cons.owner = cols.owner"; + + String query = + "SELECT case \r\n" + + " when lower(data_type) in ('number', 'numeric', 'dec', 'decimal', 'pls_integer') then 'number'\r\n" + + " when lower(data_type) in ('varchar2', 'varchar', 'char', 'nchar', 'nvarchar2') then 'string'\r\n" + + " when substr(lower(data_type), 1, instr(data_type, '(') - 1) in ('date', 'timestamp') then 'date'\r\n" + + " when lower(data_type) in ('date', 'timestamp') then 'date'\r\n" + + " when lower(data_type) in ('clob') then 'text'\r\n" + + " when lower(data_type) in ('blob') then 'binary'" + + " else 'native'\r\n" + + " end type, " + + " case when lower(data_type) in ('char', 'nchar') then 1 else 0 end fixed, " + + " ROWNUM AS NUM, TC.* FROM DBA_TAB_COLS TC \n" + + "WHERE lower(table_name) = lower('" + nameTable + "') AND lower(OWNER) = lower('" + schema + "') ORDER BY column_id"; + + try ( + Statement stmt = getConnection().createStatement(); + ResultSet pkRs = stmt.executeQuery(pkNameQuery); + ResultSet fieldsRs = stmt.executeQuery(query); + ){ + + String pkColumnName = ""; + while (pkRs.next()) { pkColumnName = pkRs.getString("COLUMN_NAME").toLowerCase(); } + + while(fieldsRs.next()){ + DBTableField field = new DBTableField(); - field.setName(rs.getString("COLUMN_NAME").toLowerCase()); - if (rs.getString("COLUMN_NAME").toLowerCase().equals(s)) { + + field.setName(fieldsRs.getString("COLUMN_NAME").toLowerCase()); + if (fieldsRs.getString("COLUMN_NAME").toLowerCase().equals(pkColumnName)) { field.setIsPrimaryKey(true); } - String typeSQL = getFieldType(rs); + String typeSQL = getFieldType(fieldsRs); field.setTypeSQL(typeSQL); field.setIsNullable( !typeSQL.toLowerCase().contains("not null")); - field.setTypeUniversal(FieldType.fromString(rs.getString("TYPE").toUpperCase())); - field.setLength(rs.getInt("DATA_LENGTH")); - field.setScale(rs.getInt("DATA_SCALE")); - field.setPrecision(rs.getInt("DATA_PRECISION")); - field.setFixed(rs.getBoolean("fixed")); - field.setOrder(rs.getInt("column_id")); + field.setTypeUniversal(FieldType.fromString(fieldsRs.getString("TYPE").toUpperCase())); + field.setLength(fieldsRs.getInt("DATA_LENGTH")); + field.setScale(fieldsRs.getInt("DATA_SCALE")); + field.setPrecision(fieldsRs.getInt("DATA_PRECISION")); + field.setFixed(fieldsRs.getBoolean("fixed")); + field.setOrder(fieldsRs.getInt("column_id")); + listField.put(field.getName(), field); } - - stmt.close(); - - return listField; - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); + + } catch(Exception e) { + logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); - } + } + + return listField; } protected String getFieldType(ResultSet rs) { @@ -342,7 +332,7 @@ protected String getFieldType(ResultSet rs) { } return type.toString(); - }catch(Exception e) { + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); } @@ -351,109 +341,109 @@ protected String getFieldType(ResultSet rs) { @Override public Map getIndexes(String schema, String nameTable) { Map indexes = new HashMap<>(); - try { - String query = "SELECT ind.index_name, (select dbms_metadata.get_ddl('INDEX', ind.INDEX_NAME, owner) AS DDL from dual) AS DDL\n" + - "FROM all_indexes ind\n" + - "WHERE upper(table_name) = upper('" + nameTable + "') AND upper(owner) = upper('" + schema + "')"; - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "SELECT ind.index_name, (select dbms_metadata.get_ddl('INDEX', ind.INDEX_NAME, owner) AS DDL from dual) AS DDL\n" + + "FROM all_indexes ind\n" + + "WHERE upper(table_name) = upper('" + nameTable + "') AND upper(owner) = upper('" + schema + "')"; + + try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);){ while(rs.next()){ - DBIndex index = new DBIndex(); - index.setName(rs.getString("INDEX_NAME")); - index.setSchema(schema); + //TODO find real owner + String name = rs.getString("INDEX_NAME"); + DBIndex index = new DBIndex(name, schema, schema); rowToProperties(rs, index.getOptions()); indexes.put(index.getName(), index); } - stmt.close(); - - return indexes; - - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "indexes").toString()); + + } catch(Exception e) { + logger.error(lang.getValue("errors", "adapter", "indexes").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "indexes").toString(), e); } + + return indexes; } @Override public Map getConstraints(String schema, String nameTable) { Map constraints = new HashMap<>(); - try { - String query = "SELECT cons.constraint_type, cons.CONSTRAINT_NAME, (select dbms_metadata.get_ddl('CONSTRAINT', cons.constraint_name, owner) AS DDL from dual) AS DDL\n" + - "FROM all_constraints cons\n" + - "WHERE upper(owner) = upper('" + schema + "') and upper(table_name) = upper('" + nameTable + "') and constraint_name not like 'SYS%' and cons.constraint_type = 'P'"; - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - + String query = + "SELECT cons.constraint_type, cons.CONSTRAINT_NAME, (select dbms_metadata.get_ddl('CONSTRAINT', cons.constraint_name, owner) AS DDL from dual) AS DDL\n" + + "FROM all_constraints cons\n" + + "WHERE upper(owner) = upper('" + schema + "') and upper(table_name) = upper('" + nameTable + "') and constraint_name not like 'SYS%' and cons.constraint_type = 'P'"; + + try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while(rs.next()){ - DBConstraint con = new DBConstraint(); - con.setName(rs.getString("CONSTRAINT_NAME")); + String name = rs.getString("CONSTRAINT_NAME"); //This is DDL? - con.setConstraintType(rs.getString("CONSTRAINT_TYPE")); - con.setSchema(schema); + String type = rs.getString("CONSTRAINT_TYPE"); + //TODO find real owner + DBConstraint con = new DBConstraint(name, schema, schema, type); rowToProperties(rs, con.getOptions()); constraints.put(con.getName(), con); } - stmt.close(); - - return constraints; - - }catch(Exception e) { + + } + catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "constraints").toString()); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "constraints").toString(), e); } + + return constraints; } @Override public Map getViews(String schema) { Map listView = new HashMap(); - try { - String query = "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('VIEW', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'VIEW'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + + String query = + "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('VIEW', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'VIEW'"; + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while(rs.next()){ - DBView view = new DBView(rs.getString("OBJECT_NAME")); - view.setSchema(rs.getString("OWNER")); - view.setOwner(rs.getString("OWNER")); + String name = rs.getString("OBJECT_NAME"); + String owner = rs.getString("OWNER"); + + DBView view = new DBView(name, schema, owner); rowToProperties(rs, view.getOptions()); listView.put(rs.getString("OBJECT_NAME"), view); + } - stmt.close(); - return listView; - }catch(Exception e) { + + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views") + ": " + e.getMessage()); + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views") + ": " + e.getMessage(), e); } + + return listView; } @Override public DBView getView(String schema, String name) { - DBView view = new DBView(name); - view.setSchema(schema); - try { - String query = "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('VIEW', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'VIEW' and f.object_name = '" + name + "'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - - view.setOwner(schema); - + DBView view = null; + + String query = + "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('VIEW', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'VIEW' and f.object_name = '" + name + "'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query); ){ + while (rs.next()) { - view.setOwner(rs.getString("OWNER")); + String owner = rs.getString("OWNER"); + + view = new DBView(name, schema, owner); rowToProperties(rs, view.getOptions()); } - stmt.close(); - return view; - - }catch(Exception e) { + + } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "views").toString() + ": "+ e.getMessage()); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views").toString(), e); } + + return view; } public Map getTriggers(String schema) { @@ -468,12 +458,14 @@ public Map getTriggers(String schema) { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ + //TODO find real owner + //what means owner? oracle/postgres or owner like database user/schema + String owner = "oracle"; String name = rs.getString("TRIGGER_NAME"); String sql = rs.getString("DDL"); - DBTrigger trigger = new DBTrigger(name); - trigger.setSchema(schema); - //what means owner? oracle/postgres or owner like database user/schema - trigger.setOwner("oracle"); + + DBTrigger trigger = new DBTrigger(name, schema, owner); + trigger.setSql(sql); rowToProperties(rs, trigger.getOptions()); listTrigger.put(name, trigger); } @@ -497,10 +489,12 @@ public DBTrigger getTrigger(String schema, String name) { try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ - trigger = new DBTrigger(name); - trigger.setSchema(schema); + + //TODO find real owner //what means owner? oracle/postgres or owner like database user/schema - trigger.setOwner("oracle"); + String owner = "oracle"; + + trigger = new DBTrigger(name, schema, owner); rowToProperties(rs, trigger.getOptions()); } @@ -524,11 +518,9 @@ public Map getPackages(String schema) { while(rs.next()){ String name = rs.getString("OBJECT_NAME"); String owner = rs.getString("OWNER"); - //String args = rs.getString("arguments"); - DBPackage pack = new DBPackage(name); - pack.setSchema(schema); - pack.setOwner(owner); + DBPackage pack = new DBPackage(name, schema, owner); rowToProperties(rs,pack.getOptions()); + //String args = rs.getString("arguments"); //pack.setArguments(args); listPackage.put(name, pack); } @@ -551,11 +543,9 @@ public DBPackage getPackage(String schema, String name) { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while (rs.next()) { - pack = new DBPackage(name); String owner = rs.getString("OWNER"); + pack = new DBPackage(name, schema, owner); //String args = rs.getString("arguments"); - pack.setSchema(schema); - pack.setOwner(owner); //pack.setArguments(args); rowToProperties(rs,pack.getOptions()); } @@ -581,12 +571,10 @@ public Map getProcedures(String schema) { while(rs.next()){ String name = rs.getString("OBJECT_NAME"); String owner = rs.getString("OWNER"); - //String args = rs.getString("arguments"); - DBProcedure proc = new DBProcedure(name); - proc.setSchema(schema); - proc.setOwner(owner); - proc.setName(name); + + DBProcedure proc = new DBProcedure(name, schema, owner); rowToProperties(rs,proc.getOptions()); + //String args = rs.getString("arguments"); //proc.setArguments(args); listProcedure.put(name, proc); } @@ -610,11 +598,10 @@ public DBProcedure getProcedure(String schema, String name) { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while (rs.next()) { - proc = new DBProcedure(rs.getString("OBJECT_NAME")); + String objName = rs.getString("OBJECT_NAME"); String owner = rs.getString("OWNER"); + proc = new DBProcedure(objName, schema, owner); //String args = rs.getString("arguments"); - proc.setSchema(schema); - proc.setOwner(owner); //proc.setArguments(args); rowToProperties(rs,proc.getOptions()); } @@ -639,11 +626,9 @@ public Map getFunctions(String schema) { String name = rs.getString("OBJECT_NAME"); String sql = rs.getString("DDL"); String owner = rs.getString("OWNER"); - //String args = rs.getString("arguments"); - DBFunction func = new DBFunction(name); - func.setSchema(schema); - func.setOwner(owner); + DBFunction func = new DBFunction(name, schema, owner); rowToProperties(rs,func.getOptions()); + //String args = rs.getString("arguments"); //func.setArguments(args); listFunction.put(name, func); } @@ -668,11 +653,10 @@ public DBFunction getFunction(String schema, String name) { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while (rs.next()) { - func = new DBFunction(rs.getString("OBJECT_NAME")); + String objName = rs.getString("OBJECT_NAME"); String owner = rs.getString("OWNER"); + func = new DBFunction(objName, schema, owner); //String args = rs.getString("arguments"); - func.setSchema(schema); - func.setOwner(owner); //func.setArguments(args); rowToProperties(rs,func.getOptions()); } @@ -690,15 +674,20 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port try { int portionSize = DBGitConfig.getInstance().getInteger("core", "PORTION_SIZE", DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000)); - int begin = 1 + portionSize*portionIndex; int end = portionSize + portionSize*portionIndex; + String dataQuery = + "SELECT * FROM (" + + " SELECT f.*, ROW_NUMBER() OVER (ORDER BY rowid) DBGIT_ROW_NUM " + + " FROM " + schema + "." + nameTable + " f" + + ") " + + "WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end; + + try(Statement st = getConnection().createStatement(); ){ + ResultSet rs = st.executeQuery(dataQuery); + data.setResultSet(rs); + } - Statement st = getConnection().createStatement(); - ResultSet rs = st.executeQuery(" SELECT * FROM \r\n" + - " (SELECT f.*, ROW_NUMBER() OVER (ORDER BY rowid) DBGIT_ROW_NUM FROM " + schema + "." + nameTable + " f)\r\n" + - " WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end); - data.setResultSet(rs); return data; } catch(Exception e) { @@ -726,7 +715,7 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port } try { - getConnection().rollback(); + getConnection().rollback(); } catch (Exception e2) { logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); } diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java index f095fbc..d06d879 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableOracle.java @@ -185,8 +185,7 @@ else if (tableconst.getOptions().get("ddl").toString().toLowerCase().startsWith( } } - public void restoreTableFieldsOracle(IMetaObject obj) throws Exception - { + public void restoreTableFieldsOracle(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -267,8 +266,7 @@ public void restoreTableFieldsOracle(IMetaObject obj) throws Exception } } - public void restoreTableIndexesOracle(IMetaObject obj) throws Exception - { + public void restoreTableIndexesOracle(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); @@ -345,7 +343,7 @@ public void restoreTableConstraintOracle(IMetaObject obj) throws Exception { for(DBConstraint constrs :restoreTable.getConstraints().values()) { if(!constrs.getConstraintType().equalsIgnoreCase("P")) { //String tblName = schema+"."+restoreTable.getTable().getName(); - + st.execute(constrs.getOptions().get("ddl").toString().replace(" " + constrs.getSchema() + ".", " " + schema + ".")); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index bdac8c1..e0fe3f8 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -6,31 +6,13 @@ import java.util.*; import java.util.concurrent.TimeUnit; -import ru.fusionsoft.dbgit.adapters.DBAdapter; -import ru.fusionsoft.dbgit.adapters.IFactoryDBAdapterRestoteMetaData; -import ru.fusionsoft.dbgit.adapters.IFactoryDBBackupAdapter; -import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; -import ru.fusionsoft.dbgit.core.DBGitConfig; -import ru.fusionsoft.dbgit.core.DBGitLang; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; +import com.diogonunes.jcdp.color.api.Ansi; +import org.apache.commons.lang3.exception.ExceptionUtils; +import ru.fusionsoft.dbgit.adapters.*; +import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.core.db.FieldType; -import ru.fusionsoft.dbgit.dbobjects.DBConstraint; -import ru.fusionsoft.dbgit.dbobjects.DBFunction; -import ru.fusionsoft.dbgit.dbobjects.DBIndex; -import ru.fusionsoft.dbgit.dbobjects.DBPackage; -import ru.fusionsoft.dbgit.dbobjects.DBProcedure; -import ru.fusionsoft.dbgit.dbobjects.DBRole; -import ru.fusionsoft.dbgit.dbobjects.DBSchema; -import ru.fusionsoft.dbgit.dbobjects.DBSequence; -import ru.fusionsoft.dbgit.dbobjects.DBTable; -import ru.fusionsoft.dbgit.dbobjects.DBTableData; -import ru.fusionsoft.dbgit.dbobjects.DBTableField; -import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; -import ru.fusionsoft.dbgit.dbobjects.DBTrigger; -import ru.fusionsoft.dbgit.dbobjects.DBUser; -import ru.fusionsoft.dbgit.dbobjects.DBView; +import ru.fusionsoft.dbgit.dbobjects.*; import ru.fusionsoft.dbgit.meta.IMapMetaObject; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -38,12 +20,13 @@ import org.slf4j.Logger; import com.axiomalaska.jdbc.NamedParameterPreparedStatement; +import ru.fusionsoft.dbgit.utils.StringProperties; public class DBAdapterPostgres extends DBAdapter { private Logger logger = LoggerUtil.getLogger(this.getClass()); private FactoryDBAdapterRestorePostgres restoreFactory = new FactoryDBAdapterRestorePostgres(); - private FactoryDbConvertAdapterPostgres convertFactory = new FactoryDbConvertAdapterPostgres(); + private FactoryDbConvertAdapterPostgres convertFactory = new FactoryDbConvertAdapterPostgres(); private FactoryDBBackupAdapterPostgres backupFactory = new FactoryDBBackupAdapterPostgres(); private static Set reservedWords = new HashSet<>(); @@ -51,7 +34,7 @@ public class DBAdapterPostgres extends DBAdapter { public IFactoryDBAdapterRestoteMetaData getFactoryRestore() { return restoreFactory; } - + @Override public void startUpdateDB() { // TODO Auto-generated method stub @@ -63,7 +46,7 @@ public void endUpdateDB() { // TODO Auto-generated method stub } - + @Override public IMapMetaObject loadCustomMetaObjects() { return null; @@ -72,50 +55,48 @@ public IMapMetaObject loadCustomMetaObjects() { @Override public Map getSchemes() { Map listScheme = new HashMap(); - try { - String query = "select nspname,usename,nspacl from pg_namespace,pg_user where nspname!='pg_toast' and nspname!='pg_temp_1'"+ - "and nspname!='pg_toast_temp_1' and nspname!='pg_catalog'"+ - "and nspname!='information_schema' and nspname!='pgagent'"+ - "and nspname!='pg_temp_3' and nspname!='pg_toast_temp_3'"+ - "and usesysid = nspowner"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "select nspname,usename,nspacl from pg_namespace,pg_user where nspname!='pg_toast' and nspname!='pg_temp_1'"+ + "and nspname!='pg_toast_temp_1' and nspname!='pg_catalog'"+ + "and nspname!='information_schema' and nspname!='pgagent'"+ + "and nspname!='pg_temp_3' and nspname!='pg_toast_temp_3'"+ + "and usesysid = nspowner"; + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ String name = rs.getString("nspname"); - DBSchema scheme = new DBSchema(name); - rowToProperties(rs, scheme.getOptions()); - listScheme.put(name, scheme); - } - stmt.close(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "schemes").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "schemes").toString(), e); - } + DBSchema scheme = new DBSchema(name, new StringProperties(rs)); + listScheme.put(name, scheme); + } + + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "schemes").toString(); + throw new ExceptionDBGitRunTime(msg, e); + } return listScheme; + } - + @Override public Map getTableSpaces() { Map listTableSpace = new HashMap(); - try { - String query = "SELECT tblspaces.spcname,tblspaces.spcacl,tblspaces.spcoptions,users.usename,pg_tablespace_location(tblspacesoid.oid) " + - "FROM pg_tablespace as tblspaces,pg_user as users,(Select oid FROM pg_tablespace where spcname!='pg_default' and spcname!='pg_global') as tblspacesoid " + - "WHERE users.usesysid=tblspaces.spcowner and spcname!='pg_default' and spcname!='pg_global' and tblspacesoid.oid=tblspaces.oid"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "SELECT tblspaces.spcname,tblspaces.spcacl,tblspaces.spcoptions,users.usename,pg_tablespace_location(tblspacesoid.oid) " + + "FROM pg_tablespace as tblspaces,pg_user as users,(Select oid FROM pg_tablespace where spcname!='pg_default' and spcname!='pg_global') as tblspacesoid " + + "WHERE users.usesysid=tblspaces.spcowner and spcname!='pg_default' and spcname!='pg_global' and tblspacesoid.oid=tblspaces.oid"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ String name = rs.getString("spcname"); - DBTableSpace dbTableSpace = new DBTableSpace(name); - rowToProperties(rs, dbTableSpace.getOptions()); + DBTableSpace dbTableSpace = new DBTableSpace(name, new StringProperties(rs)); listTableSpace.put(name, dbTableSpace); - } - stmt.close(); - }catch(Exception e) { - logger.error(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); + } + + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "tablespace").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listTableSpace; } @@ -123,144 +104,142 @@ public Map getTableSpaces() { @Override public Map getSequences(String schema) { Map listSequence = new HashMap<>(); - try { - Connection connect = getConnection(); - String query = - "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option, cl.relname as blocking_table \n" + - "from pg_class cls \n" + - " join pg_roles rol on rol.oid = cls.relowner \n" + - " join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + - " join information_schema.sequences s on cls.relname = s.sequence_name \n" + - " left join pg_depend d on d.objid=cls.oid and d.classid='pg_class'::regclass and d.refclassid='pg_class'::regclass\n" + - " left join pg_class cl on cl.oid = d.refobjid and d.deptype='a' \n" + - "where nsp.nspname not in ('information_schema', 'pg_catalog')\n" + - " and nsp.nspname not like 'pg_toast%' \n" + - " and cls.relkind = 'S' and s.sequence_schema = :schema"; - - NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); - stmt.setString("schema", schema); - - ResultSet rs = stmt.executeQuery(); + String query = MessageFormat.format( + "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option, cl.relname as blocking_table \n" + + "from pg_class cls \n" + + " join pg_roles rol on rol.oid = cls.relowner \n" + + " join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + + " join information_schema.sequences s on cls.relname = s.sequence_name \n" + + " left join pg_depend d on d.objid=cls.oid and d.classid=''pg_class''::regclass and d.refclassid=''pg_class''::regclass\n" + + " left join pg_class cl on cl.oid = d.refobjid and d.deptype=''a'' \n" + + "where nsp.nspname not in (''information_schema'', ''pg_catalog'')\n" + + " and nsp.nspname not like ''pg_toast%'' \n" + + " and cls.relkind = ''S'' and s.sequence_schema = ''{0}''", + schema + ); + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) + { + while(rs.next()){ String nameSeq = rs.getString("sequence_name"); - DBSequence sequence = new DBSequence(); - sequence.setName(nameSeq); - sequence.setSchema(schema); - sequence.setValue(0L); - rowToProperties(rs, sequence.getOptions()); + String ownerSeq = rs.getString("blocking_table"); + Long valueSeq = 0L; + //TODO find actual value + + DBSequence sequence = new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); listSequence.put(nameSeq, sequence); } - stmt.close(); - }catch(Exception e) { - logger.error(e.getMessage(), e); - throw new ExceptionDBGitRunTime(e.getMessage(), e); + + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "sequence").toString(); + throw new ExceptionDBGitRunTime(msg, e); } + return listSequence; } @Override public DBSequence getSequence(String schema, String name) { - try { - Connection connect = getConnection(); - String query = - "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option, cl.relname as blocking_table \n" + - "from pg_class cls \n" + - " join pg_roles rol on rol.oid = cls.relowner \n" + - " join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + - " join information_schema.sequences s on cls.relname = s.sequence_name \n" + - " left join pg_depend d on d.objid=cls.oid and d.classid='pg_class'::regclass and d.refclassid='pg_class'::regclass\n" + - " left join pg_class cl on cl.oid = d.refobjid and d.deptype='a' \n" + - "where nsp.nspname not in ('information_schema', 'pg_catalog') \n" + - " and nsp.nspname not like 'pg_toast%' \n" + - " and cls.relkind = 'S' and s.sequence_schema = :schema and s.sequence_name = :name "; - - NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); - stmt.setString("schema", schema); - stmt.setString("name", name); - + + String query = + "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option, cl.relname as blocking_table \n" + + "from pg_class cls \n" + + " join pg_roles rol on rol.oid = cls.relowner \n" + + " join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + + " join information_schema.sequences s on cls.relname = s.sequence_name \n" + + " left join pg_depend d on d.objid=cls.oid and d.classid='pg_class'::regclass and d.refclassid='pg_class'::regclass\n" + + " left join pg_class cl on cl.oid = d.refobjid and d.deptype='a' \n" + + "where nsp.nspname not in ('information_schema', 'pg_catalog') \n" + + " and nsp.nspname not like 'pg_toast%' \n" + + " and cls.relkind = 'S' and s.sequence_schema = :schema and s.sequence_name = :name "; + + try ( + PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "name", name)); ResultSet rs = stmt.executeQuery(); - DBSequence sequence = null; - while (rs.next()) { + ) { + if (rs.next()) { String nameSeq = rs.getString("sequence_name"); - sequence = new DBSequence(); - sequence.setName(nameSeq); - sequence.setSchema(schema); - sequence.setValue(0L); - rowToProperties(rs, sequence.getOptions()); + String ownerSeq = rs.getString("blocking_table"); + Long valueSeq = 0L; + //TODO find actual value + + return new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); + } else { + String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } - stmt.close(); - return sequence; - }catch(Exception e) { - logger.error(e.getMessage(), e); - throw new ExceptionDBGitRunTime(e.getMessage(), e); + + } catch(Exception e) { + + String msg = lang.getValue("errors", "adapter", "sequence").toString(); + throw new ExceptionDBGitRunTime(msg, e); + } } @Override public Map getTables(String schema) { Map listTable = new HashMap(); - try { - - - String query = - "SELECT \n" + - " tablename AS table_name,\n" + - " tableowner AS owner,\n" + - " tablespace, hasindexes, hasrules, hastriggers, \n" + - " obj_description( (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment,\n" + - " ( " + - " SELECT array_agg( distinct n2.nspname || '/' || c2.relname || '.tbl' ) AS dependencies\n" + - " FROM pg_catalog.pg_constraint c \n" + - " JOIN ONLY pg_catalog.pg_class c1 ON c1.oid = c.conrelid\n" + - " JOIN ONLY pg_catalog.pg_class c2 ON c2.oid = c.confrelid\n" + - " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + - " WHERE c.conrelid = (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid\n" + - " and c1.relkind = 'r' AND c.contype = 'f'\n" + - " ) " + - " AS dependencies, \n" + - ( (getDbVersionNumber() > 10) - ? " pg_get_partkeydef((" + - " SELECT oid " + - " FROM pg_class " + - " WHERE relname = tablename " + - " AND relnamespace = (select oid from pg_namespace where nspname = :schema" + - " )) " + - " AS partkeydef, \n" + - " pg_get_expr(child.relpartbound, child.oid) " + - " AS pg_get_expr, \n" + String query = + "SELECT \n" + + " tablename AS table_name,\n" + + " tableowner AS owner,\n" + + " tablespace, hasindexes, hasrules, hastriggers, \n" + + " obj_description( (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment,\n" + + " (\n" + + " SELECT array_agg( distinct n2.nspname || '/' || c2.relname || '.tbl' ) AS dependencies\n" + + " FROM pg_catalog.pg_constraint c \n" + + " JOIN ONLY pg_catalog.pg_class c1 ON c1.oid = c.conrelid\n" + + " JOIN ONLY pg_catalog.pg_class c2 ON c2.oid = c.confrelid\n" + + " JOIN ONLY pg_catalog.pg_namespace n2 ON n2.oid = c2.relnamespace\n" + + " WHERE c.conrelid = (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid\n" + + " and c1.relkind = 'r' AND c.contype = 'f'\n" + + " ) " + + " AS dependencies, \n" + + ( (getDbVersionNumber() > 10) + ? " pg_get_partkeydef((\n" + + " SELECT oid \n" + + " FROM pg_class \n" + + " WHERE relname = tablename \n" + + " AND relnamespace = (select oid from pg_namespace where nspname = :schema )\n" + + " )) \n" + + " AS partkeydef, \n" + + " pg_get_expr(child.relpartbound, child.oid) " + + " AS pg_get_expr, \n" : " " - ) + - " parent.relname AS parent \n" + - "FROM pg_tables \n" + - "LEFT OUTER JOIN pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) = pg_inherits.inhrelid \n" + - "LEFT OUTER JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + - "LEFT OUTER JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + - "WHERE upper(schemaname) = upper(:schema)"; - Connection connect = getConnection(); - - NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); - stmt.setString("schema", schema); - + ) + + " parent.relname AS parent \n" + + "FROM pg_tables \n" + + "LEFT OUTER JOIN pg_inherits on (SELECT oid FROM pg_class WHERE relname = tablename and relnamespace = (select oid from pg_namespace where nspname = :schema)) = pg_inherits.inhrelid \n" + + "LEFT OUTER JOIN pg_class parent ON pg_inherits.inhparent = parent.oid \n" + + "LEFT OUTER JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + + "WHERE upper(schemaname) = upper(:schema)"; + + try ( + PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema)); ResultSet rs = stmt.executeQuery(); + ) { + + while(rs.next()){ String nameTable = rs.getString("table_name"); - DBTable table = new DBTable(nameTable); - table.setSchema(schema); - table.setComment(rs.getString("table_comment")); - if(rs.getArray("dependencies") != null){ - table.setDependencies(new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray()))); - } else table.setDependencies(new HashSet<>()); + String ownerTable = rs.getString("owner"); + String commentTable = rs.getString("table_comment"); + Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); + if (rs.getString("parent") != null) { - table.getDependencies().add(schema + "/" + rs.getString("parent") + ".tbl"); + dependencies.add(schema + "/" + rs.getString("parent") + ".tbl"); } - rowToProperties(rs, table.getOptions()); + DBTable table = new DBTable(nameTable, new StringProperties(rs), schema, ownerTable, dependencies, commentTable); listTable.put(nameTable, table); } - stmt.close(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + } catch (Exception e) { + String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listTable; } @@ -272,8 +251,8 @@ public DBTable getTable(String schema, String name) { " tablename AS table_name,\n" + " tableowner AS owner,\n" + " tablespace, hasindexes, hasrules, hastriggers, \n" + - " obj_description( (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment, " + - " ( " + + " obj_description( (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment,\n" + + " (\n" + " SELECT array_agg( distinct n2.nspname || '/' || c2.relname || '.tbl' ) AS dependencies\n" + " FROM pg_catalog.pg_constraint c \n" + " JOIN ONLY pg_catalog.pg_class c1 ON c1.oid = c.conrelid\n" + @@ -284,12 +263,12 @@ public DBTable getTable(String schema, String name) { " ) " + " AS dependencies, \n" + ( (getDbVersionNumber() > 10) - ? " pg_get_partkeydef((" + - " SELECT oid " + - " FROM pg_class " + - " WHERE relname = tablename " + - " AND relnamespace = (select oid from pg_namespace where nspname = :schema" + - " )) " + + ? " pg_get_partkeydef((\n" + + " SELECT oid \n" + + " FROM pg_class \n" + + " WHERE relname = tablename \n" + + " AND relnamespace = (select oid from pg_namespace where nspname = :schema )\n" + + " )) \n" + " AS partkeydef, \n" + " pg_get_expr(child.relpartbound, child.oid) " + " AS pg_get_expr, \n" @@ -302,619 +281,664 @@ public DBTable getTable(String schema, String name) { "LEFT OUTER JOIN pg_class child ON pg_inherits.inhrelid = child.oid \n" + "WHERE upper(schemaname) = upper(:schema)" + "AND tablename = :name"; - try { - - Connection connect = getConnection(); - - NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); - stmt.setString("schema", schema); - stmt.setString("name", name); - + try ( + PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "name", name)); ResultSet rs = stmt.executeQuery(); + ) { - DBTable table = null; - - while (rs.next()) { + + if (rs.next()) { String nameTable = rs.getString("table_name"); - table = new DBTable(nameTable); - table.setSchema(schema); - table.setComment(rs.getString("table_comment")); - if(rs.getArray("dependencies") != null){ - table.setDependencies(new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray()))); - } else table.setDependencies(new HashSet<>()); + String ownerTable = rs.getString("owner"); + String commentTable = rs.getString("table_comment"); + Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); + if (rs.getString("parent") != null) { - table.getDependencies().add(schema + "/" + rs.getString("parent") + ".tbl"); + dependencies.add(schema + "/" + rs.getString("parent") + ".tbl"); } - rowToProperties(rs, table.getOptions()); + return new DBTable(nameTable, new StringProperties(rs), schema, ownerTable, dependencies, commentTable); + + } else { + String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } - stmt.close(); - return table; - - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public Map getTableFields(String schema, String nameTable) { - - try { - Map listField = new HashMap(); - - String query = - "SELECT distinct col.column_name,col.is_nullable,col.data_type, col.udt_name::regtype dtype,col.character_maximum_length, col.column_default, tc.constraint_name, " + - "case\r\n" + - " when lower(data_type) in ('integer', 'numeric', 'smallint', 'double precision', 'bigint') then 'number' \r\n" + - " when lower(data_type) in ('character varying', 'char', 'character', 'varchar') then 'string'\r\n" + - " when lower(data_type) in ('timestamp without time zone', 'timestamp with time zone', 'date') then 'date'\r\n" + - " when lower(data_type) in ('boolean') then 'boolean'\r\n" + - " when lower(data_type) in ('text') then 'text'\r\n" + - " when lower(data_type) in ('bytea') then 'binary'" + - " else 'native'\r\n" + - " end tp, " + - " case when lower(data_type) in ('char', 'character') then true else false end fixed, " + - " pgd.description," + - "col.* FROM " + - "information_schema.columns col " + - "left join information_schema.key_column_usage kc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and col.column_name=kc.column_name " + - "left join information_schema.table_constraints tc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and kc.constraint_name = tc.constraint_name and tc.constraint_type = 'PRIMARY KEY' " + - "left join pg_catalog.pg_statio_all_tables st on st.schemaname = col.table_schema and st.relname = col.table_name " + - "left join pg_catalog.pg_description pgd on (pgd.objoid=st.relid and pgd.objsubid=col.ordinal_position) " + - "where upper(col.table_schema) = upper(:schema) and col.table_name = :table " + - "order by col.column_name "; - Connection connect = getConnection(); - - NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); - stmt.setString("schema", schema); - stmt.setString("table", nameTable); - + Map listField = new HashMap(); + String query = + "SELECT distinct col.column_name,col.is_nullable,col.data_type, col.udt_name::regtype dtype,col.character_maximum_length, col.column_default, tc.constraint_name, " + + "case\r\n" + + " when lower(data_type) in ('integer', 'numeric', 'smallint', 'double precision', 'bigint') then 'number' \r\n" + + " when lower(data_type) in ('character varying', 'char', 'character', 'varchar') then 'string'\r\n" + + " when lower(data_type) in ('timestamp without time zone', 'timestamp with time zone', 'date') then 'date'\r\n" + + " when lower(data_type) in ('boolean') then 'boolean'\r\n" + + " when lower(data_type) in ('text') then 'text'\r\n" + + " when lower(data_type) in ('bytea') then 'binary'" + + " else 'native'\r\n" + + " end tp, " + + " case when lower(data_type) in ('char', 'character') then true else false end fixed, " + + " pgd.description," + + "col.* FROM " + + "information_schema.columns col " + + "left join information_schema.key_column_usage kc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and col.column_name=kc.column_name " + + "left join information_schema.table_constraints tc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and kc.constraint_name = tc.constraint_name and tc.constraint_type = 'PRIMARY KEY' " + + "left join pg_catalog.pg_statio_all_tables st on st.schemaname = col.table_schema and st.relname = col.table_name " + + "left join pg_catalog.pg_description pgd on (pgd.objoid=st.relid and pgd.objsubid=col.ordinal_position) " + + "where upper(col.table_schema) = upper(:schema) and col.table_name = :table " + + "order by col.column_name "; + + try ( + PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "table", nameTable)); ResultSet rs = stmt.executeQuery(); - while(rs.next()){ + ) { + + + while(rs.next()){ DBTableField field = new DBTableField(); - - field.setName(rs.getString("column_name")); - field.setDescription(rs.getString("description")); - field.setNameExactly(!rs.getString("column_name").equals(rs.getString("column_name").toLowerCase())); - if (rs.getString("constraint_name") != null) { - field.setIsPrimaryKey(true); - } String typeSQL = getFieldType(rs); - field.setTypeSQL(typeSQL); - field.setIsNullable( !typeSQL.toLowerCase().contains("not null")); - field.setTypeUniversal(FieldType.fromString(rs.getString("tp"))); + String nameField = rs.getString("column_name"); + String descField = rs.getString("description"); + String columnDefault = rs.getString("column_default"); + boolean isFixed = rs.getBoolean("fixed"); + boolean isNameExactly = !rs.getString("column_name").equals(rs.getString("column_name").toLowerCase()); + boolean isPrimaryKey = rs.getString("constraint_name") != null; + boolean isNullable = !typeSQL.toLowerCase().contains("not null"); + FieldType typeUniversal = FieldType.fromString(rs.getString("tp")); + int length = rs.getInt("character_maximum_length"); + int precision = rs.getInt("numeric_precision"); + int scale = rs.getInt("numeric_scale"); + int ordinalPosition = rs.getInt("ordinal_position"); //TODO more verbose type override - if(field.getTypeUniversal() == FieldType.TEXT) field.setTypeUniversal(FieldType.STRING_NATIVE); + typeUniversal = typeUniversal.equals(FieldType.TEXT) ? FieldType.STRING_NATIVE : typeUniversal; + + field.setName(nameField); + field.setDescription(descField); + field.setNameExactly(isNameExactly); + field.setIsPrimaryKey(isPrimaryKey); + field.setTypeUniversal(typeUniversal); + field.setTypeSQL(typeSQL); + field.setIsNullable(isNullable); field.setFixed(false); - field.setLength(rs.getInt("character_maximum_length")); - field.setPrecision(rs.getInt("numeric_precision")); - field.setScale(rs.getInt("numeric_scale")); - field.setFixed(rs.getBoolean("fixed")); - field.setOrder(rs.getInt("ordinal_position")); - field.setDefaultValue(rs.getString("column_default")); - listField.put(field.getName(), field); + field.setLength(length); + field.setPrecision(precision); + field.setScale(scale); + field.setFixed(isFixed); + field.setOrder(ordinalPosition); + field.setDefaultValue(columnDefault); + + listField.put(nameField, field); } - stmt.close(); - - return listField; - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); - } + + + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); + } + + return listField; } private String getFieldType(ResultSet rs) { try { - StringBuilder type = new StringBuilder(); + StringBuilder type = new StringBuilder(); type.append(rs.getString("dtype")); - + Integer max_length = rs.getInt("character_maximum_length"); if (!rs.wasNull()) { type.append("("+max_length.toString()+")"); } if (rs.getString("is_nullable").equals("NO")){ type.append(" NOT NULL"); - } - + } + return type.toString(); }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); + logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); - } + } } @Override public Map getIndexes(String schema, String nameTable) { Map indexes = new HashMap<>(); - try { - String query = "select i.schemaname,\r\n" + - "i.tablename, \r\n" + - "i.indexname, \r\n" + - "i.tablespace, \r\n" + - "i.indexdef as ddl \r\n" + - "from \r\n" + - "pg_indexes as i JOIN pg_class as cl \r\n" + - " on i.indexname = cl.relname\r\n" + - "JOIN pg_index AS idx \r\n" + - " ON cl.oid = idx.indexrelid\r\n" + - "where i.tablename not like 'pg%' and i.schemaname = :schema and i.tablename = :table and idx.indisprimary = false -- and idx.indisunique=false "; - - Connection connect = getConnection(); - NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); - stmt.setString("schema", schema); - stmt.setString("table", nameTable); - + String query = + "SELECT " + + " i.schemaname,\r\n" + + " i.tablename, \r\n" + + " i.indexname, \r\n" + + " i.tablespace, \r\n" + + " i.indexdef AS ddl, \r\n" + + " t.tableowner AS owner \r\n" + + "FROM pg_indexes AS i " + + "JOIN pg_class AS cl ON i.indexname = cl.relname\r\n" + + "JOIN pg_index AS idx ON cl.oid = idx.indexrelid\r\n" + + "JOIN pg_tables AS t ON i.schemaname = t.schemaname AND i.tablename = t.tablename\r\n" + + "WHERE i.tablename not like 'pg%' " + + "AND i.schemaname = :schema " + + "AND i.tablename = :table and idx.indisprimary = false " + + "-- AND idx.indisunique=false "; + + try ( + PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "table", nameTable)); ResultSet rs = stmt.executeQuery(); + ){ + while(rs.next()){ - DBIndex index = new DBIndex(); - index.setName(rs.getString("indexname")); - index.setSchema(schema); - rowToProperties(rs, index.getOptions()); - indexes.put(index.getName(), index); + String name = rs.getString("indexname"); + String owner = rs.getString("owner"); + String ddl = rs.getString("ddl"); + DBIndex index = new DBIndex(name, new StringProperties(rs), schema, owner, Collections.emptySet(), ddl); + + indexes.put(name, index); } - stmt.close(); - + return indexes; - - }catch(Exception e) { + + } catch(Exception e) { String msg = lang.getValue("errors", "adapter", "indexes").toString(); - logger.error(msg); throw new ExceptionDBGitRunTime(msg, e); } - + } @Override public Map getConstraints(String schema, String nameTable) { Map constraints = new HashMap<>(); - try { - /* - String query = "select conname as constraint_name,contype as constraint_type, " + - " pg_catalog.pg_get_constraintdef(r.oid, true) as ddl " + - "from " + - " pg_class c " + - " join pg_namespace n on n.oid = c.relnamespace " + - " join pg_catalog.pg_constraint r on r.conrelid = c.relfilenode " + - "WHERE " + - " relname = :table and nspname = :schema and c.relkind = 'r'"; - */ - - - String query = "SELECT conname as constraint_name,contype as constraint_type, \r\n" + - " pg_catalog.pg_get_constraintdef(con.oid, true) as ddl\r\n" + - " FROM pg_catalog.pg_constraint con\r\n" + - " INNER JOIN pg_catalog.pg_class rel\r\n" + - " ON rel.oid = con.conrelid\r\n" + - " INNER JOIN pg_catalog.pg_namespace nsp\r\n" + - " ON nsp.oid = connamespace\r\n" + - " WHERE nsp.nspname = :schema\r\n" + - " AND rel.relname = :table"; - - - - Connection connect = getConnection(); - NamedParameterPreparedStatement stmt = NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); - stmt.setString("table", nameTable); - stmt.setString("schema", schema); - + /* + String query = "select conname as constraint_name,contype as constraint_type, " + + " pg_catalog.pg_get_constraintdef(r.oid, true) as ddl " + + "from " + + " pg_class c " + + " join pg_namespace n on n.oid = c.relnamespace " + + " join pg_catalog.pg_constraint r on r.conrelid = c.relfilenode " + + "WHERE " + + " relname = :table and nspname = :schema and c.relkind = 'r'"; + */ + + String query = + "SELECT " + + " t.tableowner as owner," + + " conname as constraint_name," + + " contype as constraint_type, \r\n" + + " pg_catalog.pg_get_constraintdef(con.oid, true) as ddl\r\n" + + "FROM pg_catalog.pg_constraint con\r\n" + + "INNER JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid\r\n" + + "INNER JOIN pg_catalog.pg_namespace nsp ON nsp.oid = connamespace\r\n" + + "INNER JOIN pg_tables t ON nsp.nspname = t.schemaname AND rel.relname = t.tablename\r\n" + + "WHERE nsp.nspname = :schema\r\n" + + "AND rel.relname = :table"; + + try ( + PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "table", nameTable)); ResultSet rs = stmt.executeQuery(); + ){ + while(rs.next()){ - DBConstraint con = new DBConstraint(); - con.setName(rs.getString("constraint_name")); - con.setConstraintType(rs.getString("constraint_type")); - con.setSchema(schema); - rowToProperties(rs, con.getOptions()); + String name = rs.getString("constraint_name"); + String type = rs.getString("constraint_type"); + String owner = rs.getString("owner"); + String ddl = rs.getString("ddl"); + StringProperties options = new StringProperties(rs); + DBConstraint con = new DBConstraint(name, options, schema, owner, Collections.emptySet(), ddl, type); + constraints.put(con.getName(), con); } - stmt.close(); - - return constraints; - - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "constraints").toString()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "constraints").toString(), e); + + return constraints; + + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "constraints").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } - + @Override public Map getViews(String schema) { Map listView = new HashMap(); - try { - String query = - "select nsp.nspname as object_schema, cls.relname as object_name, rol.rolname as owner, \n" + - "'create or replace view ' || nsp.nspname || '.' || cls.relname || ' as ' || pg_get_viewdef(cls.oid) as ddl, (\n" + - " select array_agg(distinct source_ns.nspname || '/' || source_table.relname || '.vw') as dependencySam\n" + - " from pg_depend \n" + - " join pg_rewrite ON pg_depend.objid = pg_rewrite.oid \n" + - " join pg_class as dependent_view ON pg_rewrite.ev_class = dependent_view.oid \n" + - " join pg_class as source_table ON pg_depend.refobjid = source_table.oid AND source_table.relkind = 'v'\n" + - " join pg_attribute ON pg_attribute.attrelid = pg_depend.refobjid \n" + - " and pg_attribute.attnum = pg_depend.refobjsubid \n" + - " join pg_namespace dependent_ns ON dependent_ns.oid = dependent_view.relnamespace\n" + - " join pg_namespace source_ns ON source_ns.oid = source_table.relnamespace\n" + - " where pg_attribute.attnum > 0 \n" + - " and dependent_view.relname = cls.relname\n" + - ") as dependencies\n" + - "from pg_class cls \n" + - "join pg_roles rol on rol.oid = cls.relowner \n" + - "join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + - "where nsp.nspname not in ('information_schema', 'pg_catalog') \n" + - "and cls.relname not in ('pg_buffercache', 'pg_stat_statements') \n" + - "and nsp.nspname not like 'pg_toast%' \n" + - "and cls.relkind = 'v' \n" + - "and nsp.nspname = '"+schema+"' \n"; - - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "select nsp.nspname as object_schema, cls.relname as object_name, rol.rolname as owner, \n" + + "'create or replace view ' || nsp.nspname || '.' || cls.relname || ' as ' || pg_get_viewdef(cls.oid) as ddl, (\n" + + " select array_agg(distinct source_ns.nspname || '/' || source_table.relname || '.vw') as dependencySam\n" + + " from pg_depend \n" + + " join pg_rewrite ON pg_depend.objid = pg_rewrite.oid \n" + + " join pg_class as dependent_view ON pg_rewrite.ev_class = dependent_view.oid \n" + + " join pg_class as source_table ON pg_depend.refobjid = source_table.oid AND source_table.relkind = 'v'\n" + + " join pg_attribute ON pg_attribute.attrelid = pg_depend.refobjid \n" + + " and pg_attribute.attnum = pg_depend.refobjsubid \n" + + " join pg_namespace dependent_ns ON dependent_ns.oid = dependent_view.relnamespace\n" + + " join pg_namespace source_ns ON source_ns.oid = source_table.relnamespace\n" + + " where pg_attribute.attnum > 0 \n" + + " and dependent_view.relname = cls.relname\n" + + ") as dependencies\n" + + "from pg_class cls \n" + + "join pg_roles rol on rol.oid = cls.relowner \n" + + "join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + + "where nsp.nspname not in ('information_schema', 'pg_catalog') \n" + + "and cls.relname not in ('pg_buffercache', 'pg_stat_statements') \n" + + "and nsp.nspname not like 'pg_toast%' \n" + + "and cls.relkind = 'v' \n" + + "and nsp.nspname = '"+schema+"' \n"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ while(rs.next()){ - DBView view = new DBView(rs.getString("object_name")); - view.setSchema(rs.getString("object_schema")); - view.setOwner(rs.getString("owner")); - rowToProperties(rs, view.getOptions()); - if(rs.getArray("dependencies") != null){ - view.setDependencies(new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray()))); - } + String objectName = rs.getString("object_name"); + String objectSchema = rs.getString("object_schema"); + String owner = rs.getString("owner"); + String ddl = rs.getString("ddl"); + StringProperties options = new StringProperties(rs); + Set dependencies = rs.getArray("dependencies") == null + ? Collections.emptySet() + : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + + DBView view = new DBView(objectName, options, objectSchema, owner, dependencies, ddl); listView.put(rs.getString("object_name"), view); } - stmt.close(); - return listView; } catch (Exception e) { logger.error(e.getMessage()); System.out.println(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); } + + return listView; } @Override public DBView getView(String schema, String name) { - DBView view = new DBView(name); - view.setSchema(schema); - view.setDependencies(new HashSet<>()); - try { - - String query = - "select nsp.nspname as object_schema, cls.relname as object_name, rol.rolname as owner, \n" + - "'create or replace view ' || nsp.nspname || '.' || cls.relname || ' as ' || pg_get_viewdef(cls.oid) as ddl, (\n" + - " select array_agg(distinct source_ns.nspname || '/' || source_table.relname || '.vw') as dependencySam\n" + - " from pg_depend \n" + - " join pg_rewrite ON pg_depend.objid = pg_rewrite.oid \n" + - " join pg_class as dependent_view ON pg_rewrite.ev_class = dependent_view.oid \n" + - " join pg_class as source_table ON pg_depend.refobjid = source_table.oid AND source_table.relkind = 'v'\n" + - " join pg_attribute ON pg_attribute.attrelid = pg_depend.refobjid \n" + - " and pg_attribute.attnum = pg_depend.refobjsubid \n" + - " join pg_namespace dependent_ns ON dependent_ns.oid = dependent_view.relnamespace\n" + - " join pg_namespace source_ns ON source_ns.oid = source_table.relnamespace\n" + - " where pg_attribute.attnum > 0 \n" + - " and dependent_view.relname = cls.relname\n" + - ") as dependencies\n" + - "from pg_class cls \n" + - "join pg_roles rol on rol.oid = cls.relowner \n" + - "join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + - "where nsp.nspname not in ('information_schema', 'pg_catalog') \n" + - "and nsp.nspname not like 'pg_toast%' \n" + - "and cls.relkind = 'v' \n" + - "and nsp.nspname = '"+schema+"' \n" + - "and cls.relname='"+name+"'\n"; - - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - - while (rs.next()) { - view.setOwner(rs.getString("owner")); - if(rs.getArray("dependencies") != null){ - view.setDependencies(new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray()))); - } - rowToProperties(rs, view.getOptions()); + String query = + "select nsp.nspname as object_schema, cls.relname as object_name, rol.rolname as owner, \n" + + "'create or replace view ' || nsp.nspname || '.' || cls.relname || ' as ' || pg_get_viewdef(cls.oid) as ddl, (\n" + + " select array_agg(distinct source_ns.nspname || '/' || source_table.relname || '.vw') as dependencySam\n" + + " from pg_depend \n" + + " join pg_rewrite ON pg_depend.objid = pg_rewrite.oid \n" + + " join pg_class as dependent_view ON pg_rewrite.ev_class = dependent_view.oid \n" + + " join pg_class as source_table ON pg_depend.refobjid = source_table.oid AND source_table.relkind = 'v'\n" + + " join pg_attribute ON pg_attribute.attrelid = pg_depend.refobjid \n" + + " and pg_attribute.attnum = pg_depend.refobjsubid \n" + + " join pg_namespace dependent_ns ON dependent_ns.oid = dependent_view.relnamespace\n" + + " join pg_namespace source_ns ON source_ns.oid = source_table.relnamespace\n" + + " where pg_attribute.attnum > 0 \n" + + " and dependent_view.relname = cls.relname\n" + + ") as dependencies\n" + + "from pg_class cls \n" + + "join pg_roles rol on rol.oid = cls.relowner \n" + + "join pg_namespace nsp on nsp.oid = cls.relnamespace \n" + + "where nsp.nspname not in ('information_schema', 'pg_catalog') \n" + + "and nsp.nspname not like 'pg_toast%' \n" + + "and cls.relkind = 'v' \n" + + "and nsp.nspname = '"+schema+"' \n" + + "and cls.relname='"+name+"'\n"; + + + + + try(Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + + if (rs.next()) { + String owner = rs.getString("owner"); + String ddl = rs.getString("ddl"); + StringProperties options = new StringProperties(rs); + Set dependencies = rs.getArray("dependencies") == null + ? Collections.emptySet() + : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + + return new DBView(name, options, schema, owner, dependencies, ddl); + + } else { + String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } - - stmt.close(); - return view; - - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); - } + } catch(Exception e) { + DBGitLang msg = lang.getValue("errors", "adapter", "views"); + throw new ExceptionDBGitRunTime(msg, e); + } } - + @Override public Map getTriggers(String schema) { Map listTrigger = new HashMap(); - try { - String query = "SELECT trg.tgname, tbl.relname as trigger_table ,pg_get_triggerdef(trg.oid) AS ddl \r\n" + - "FROM pg_trigger trg\r\n" + - "JOIN pg_class tbl on trg.tgrelid = tbl.oid\r\n" + - "JOIN pg_namespace ns ON ns.oid = tbl.relnamespace\r\n" + - "and trg.tgconstraint=0 and ns.nspname like \'"+schema+"\'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); + String query = + "SELECT trg.tgname, tbl.relname as trigger_table ,pg_get_triggerdef(trg.oid) AS ddl \r\n" + + "FROM pg_trigger trg\r\n" + + "JOIN pg_class tbl on trg.tgrelid = tbl.oid\r\n" + + "JOIN pg_namespace ns ON ns.oid = tbl.relnamespace\r\n" + + "and trg.tgconstraint=0 and ns.nspname like \'"+schema+"\'"; + + try ( + Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query); + ) { + while(rs.next()){ String name = rs.getString("tgname"); + String owner = "postgres"; String sql = rs.getString("ddl"); - DBTrigger trigger = new DBTrigger(name); - trigger.setSchema(schema); - trigger.setOwner("postgres"); - rowToProperties(rs, trigger.getOptions()); + StringProperties options = new StringProperties(rs); + Set dependencies = rs.getArray("dependencies") == null + ? Collections.emptySet() + : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + + DBTrigger trigger = new DBTrigger(name, options, schema, owner, dependencies, sql); listTrigger.put(name, trigger); } - stmt.close(); - return listTrigger; }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); } + + return listTrigger; } @Override public DBTrigger getTrigger(String schema, String name) { - DBTrigger trigger = null; - try { - String query = "SELECT trg.tgname, tbl.relname as trigger_table ,pg_get_triggerdef(trg.oid) AS ddl \r\n" + - "FROM pg_trigger trg\r\n" + - "JOIN pg_class tbl on trg.tgrelid = tbl.oid\r\n" + - "JOIN pg_namespace ns ON ns.oid = tbl.relnamespace\r\n" + - "and trg.tgconstraint=0 and ns.nspname like \'"+schema+"\' and trg.tgname like \'"+name+"\'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - while(rs.next()){ + String query = + "SELECT trg.tgname, tbl.relname as trigger_table ,pg_get_triggerdef(trg.oid) AS ddl \r\n" + + "FROM pg_trigger trg\r\n" + + "JOIN pg_class tbl on trg.tgrelid = tbl.oid\r\n" + + "JOIN pg_namespace ns ON ns.oid = tbl.relnamespace\r\n" + + "AND trg.tgconstraint=0 and ns.nspname like \'"+schema+"\' and trg.tgname like \'"+name+"\'"; + + try (Statement stmt = getConnection().createStatement();ResultSet rs = stmt.executeQuery(query);){ + + if(rs.next()){ String sql = rs.getString("ddl"); - trigger = new DBTrigger(name); - trigger.setSchema(schema); - trigger.setOwner("postgres"); - rowToProperties(rs, trigger.getOptions()); + String owner = "postgres"; + + StringProperties options = new StringProperties(rs); + Set dependencies = rs.getArray("dependencies") == null + ? Collections.emptySet() + : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + + return new DBTrigger(name, options, schema, owner, dependencies, sql); + + } else { + String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } - stmt.close(); - return trigger; - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); } } @Override public Map getPackages(String schema) { - // TODO Auto-generated method stub - return null; + throw new ExceptionDBGitRunTime(new ExceptionDBGitObjectNotFound("cannot get packages on postgres")); +// return Collections.emptyMap(); } @Override - public DBPackage getPackage(String schema, String name) { - // TODO Auto-generated method stub - return null; + public DBPackage getPackage(String schema, String name) { + throw new ExceptionDBGitRunTime(new ExceptionDBGitObjectNotFound("cannot get packages on postgres")); + } @Override public Map getProcedures(String schema) { Map mapProcs = new HashMap<>(); - try { - String query = - "SELECT n.nspname AS \"schema\", u.rolname, p.proname AS \"name\", \n" + - " pg_catalog.pg_get_function_arguments(p.oid) AS \"arguments\",\n" + - " pg_get_functiondef(p.oid) AS ddl\n" + - "FROM pg_catalog.pg_proc p\n" + - " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + - " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - ( (getDbVersionNumber() > 10) - ? "WHERE p.prokind = 'p' \n" - : "WHERE 1=0 \n" - ) + - " AND n.nspname not in('pg_catalog', 'information_schema')\n" + - " AND n.nspname = '"+schema+"'"; + String query = + "SELECT n.nspname AS \"schema\", u.rolname, p.proname AS \"name\", \n" + + " pg_catalog.pg_get_function_arguments(p.oid) AS \"arguments\",\n" + + " pg_get_functiondef(p.oid) AS ddl\n" + + "FROM pg_catalog.pg_proc p\n" + + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + + ( (getDbVersionNumber() > 10) + ? "WHERE p.prokind = 'p' \n" + : "WHERE 1=0 \n" + ) + + " AND n.nspname not in('pg_catalog', 'information_schema')\n" + + " AND n.nspname = '"+schema+"'"; + + try (Statement stmt = getConnection().createStatement();ResultSet rs = stmt.executeQuery(query);){ - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); while(rs.next()){ String name = rs.getString("name"); String owner = rs.getString("rolname"); - DBProcedure proc = new DBProcedure(name); - proc.setSchema(schema); - proc.setOwner(owner); - rowToProperties(rs,proc.getOptions()); + String sql = rs.getString("ddl"); + StringProperties options = new StringProperties(rs); + Set dependencies = rs.getArray("dependencies") == null + ? Collections.emptySet() + : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + + DBProcedure proc = new DBProcedure(name, options, schema, owner, dependencies, sql); - mapProcs.put(mapProcs.containsKey(name) ? name + "_" + proc.getHash() : name, proc); + String nameInMap = mapProcs.containsKey(name) ? name + "_" + proc.getHash() : name; + mapProcs.put(nameInMap, proc); } - stmt.close(); - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); + + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "prc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } + return mapProcs; } @Override public DBProcedure getProcedure(String schema, String name) { - DBProcedure proc = null; - try { - String query = - "SELECT n.nspname AS \"schema\", u.rolname, p.proname AS \"name\", \n" + - " pg_catalog.pg_get_function_arguments(p.oid) AS \"arguments\",\n" + - " pg_get_functiondef(p.oid) AS ddl\n" + - "FROM pg_catalog.pg_proc p\n" + - " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + - " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + + String query = + "SELECT n.nspname AS \"schema\", u.rolname, p.proname AS \"name\", \n" + + " pg_catalog.pg_get_function_arguments(p.oid) AS \"arguments\",\n" + + " pg_get_functiondef(p.oid) AS ddl\n" + + "FROM pg_catalog.pg_proc p\n" + + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + ( (getDbVersionNumber() > 10) - ? "WHERE p.prokind = 'p' \n" - : "WHERE 1=0 \n" + ? "WHERE p.prokind = 'p' \n" + : "WHERE 1=0 \n" ) + - " AND n.nspname not in('pg_catalog', 'information_schema')\n" + - " AND n.nspname = '"+schema+"'" + - " AND p.proname = '"+name+"'"; + " AND n.nspname not in('pg_catalog', 'information_schema')\n" + + " AND n.nspname = '"+schema+"'" + + " AND p.proname = '"+name+"'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - while(rs.next()){ - proc = new DBProcedure(rs.getString("name")); - proc.setOwner(rs.getString("rolname")); - proc.setSchema(schema); - rowToProperties(rs,proc.getOptions()); + try (Statement stmt = getConnection().createStatement();ResultSet rs = stmt.executeQuery(query);){ + + if(rs.next()){ + String owner = rs.getString("rolname"); + String sql = rs.getString("ddl"); + StringProperties options = new StringProperties(rs); + Set dependencies = rs.getArray("dependencies") == null + ? Collections.emptySet() + : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + + return new DBProcedure(name, options, schema, owner, dependencies, sql); + + } else { + String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } - stmt.close(); - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "prc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return proc; } @Override public Map getFunctions(String schema) { Map listFunction = new HashMap(); - try { - String query = - "SELECT n.nspname AS \"schema\", u.rolname, p.proname AS \"name\", \n" + - " pg_catalog.pg_get_function_arguments(p.oid) AS \"arguments\",\n" + - " pg_get_functiondef(p.oid) AS ddl\n" + - "FROM pg_catalog.pg_proc p\n" + - " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + - " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + + String query = + "SELECT n.nspname AS \"schema\", u.rolname, p.proname AS \"name\", \n" + + " pg_catalog.pg_get_function_arguments(p.oid) AS \"arguments\",\n" + + " pg_get_functiondef(p.oid) AS ddl\n" + + "FROM pg_catalog.pg_proc p\n" + + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + ( (getDbVersionNumber() > 10) - ? "WHERE p.prokind = 'f' \n" - : "WHERE 1=1 " + ? "WHERE p.prokind = 'f' \n" + : "WHERE 1=1 " )+ - "AND n.nspname not in('pg_catalog', 'information_schema')\n" + - "AND n.nspname = '"+schema+"'"; + "AND n.nspname not in('pg_catalog', 'information_schema')\n" + + "AND n.nspname = '"+schema+"'"; + + try (Statement stmt = getConnection().createStatement();ResultSet rs = stmt.executeQuery(query);){ - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); while(rs.next()){ String name = rs.getString("name"); String owner = rs.getString("rolname"); - String args = rs.getString("arguments"); - DBFunction func = new DBFunction(name); - func.setSchema(schema); - func.setOwner(owner); - rowToProperties(rs,func.getOptions()); - //func.setArguments(args); - - listFunction.put(listFunction.containsKey(name) ? name + "_" + func.getHash() : name, func); + String sql = rs.getString("ddl"); + StringProperties options = new StringProperties(rs); + Set dependencies = rs.getArray("dependencies") == null + ? Collections.emptySet() + : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + + DBFunction dbFunction = new DBFunction(name, options, schema, owner, dependencies, sql); + + String nameInMap = listFunction.containsKey(name) ? name + "_" + dbFunction.getHash() : name; + listFunction.put(nameInMap, dbFunction); } - stmt.close(); + }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); + String msg = lang.getValue("errors", "adapter", "fnc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listFunction; } @Override public DBFunction getFunction(String schema, String name) { - - try { - String query = - "SELECT n.nspname AS \"schema\", u.rolname, p.proname AS \"name\", \n" + - " pg_catalog.pg_get_function_arguments(p.oid) AS \"arguments\",\n" + - " pg_get_functiondef(p.oid) AS ddl\n" + - "FROM pg_catalog.pg_proc p\n" + - " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + - " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + + String query = + "SELECT n.nspname AS \"schema\", u.rolname, p.proname AS \"name\", \n" + + " pg_catalog.pg_get_function_arguments(p.oid) AS \"arguments\",\n" + + " pg_get_functiondef(p.oid) AS ddl\n" + + "FROM pg_catalog.pg_proc p\n" + + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + ( (getDbVersionNumber() > 10) - ? "WHERE p.prokind = 'f' \n" - : "WHERE 1=1 \n" + ? "WHERE p.prokind = 'f' \n" + : "WHERE 1=1 \n" ) + - "AND n.nspname not in('pg_catalog', 'information_schema')\n" + - "AND n.nspname = '"+schema+"' AND p.proname = '"+name+"'"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + "AND n.nspname not in('pg_catalog', 'information_schema')\n" + + "AND n.nspname = '"+schema+"' AND p.proname = '"+name+"'"; - DBFunction func = null; - while (rs.next()) { - func = new DBFunction(rs.getString("name")); + try (Statement stmt = getConnection().createStatement();ResultSet rs = stmt.executeQuery(query);){ + + + if (rs.next()) { String owner = rs.getString("rolname"); - String args = rs.getString("arguments"); - func.setSchema(schema); - func.setOwner(owner); + String sql = rs.getString("ddl"); + StringProperties options = new StringProperties(rs); + Set dependencies = rs.getArray("dependencies") == null + ? Collections.emptySet() + : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + + return new DBFunction(name, options, schema, owner, dependencies, sql); + //String args = rs.getString("arguments"); //func.setArguments(args); - rowToProperties(rs,func.getOptions()); + + } else { + String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } - stmt.close(); - - return func; - - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); + + + } catch(Exception e) { + String msg = lang.getValue("errors", "adapter", "fnc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public DBTableData getTableDataPortion(String schema, String nameTable, int portionIndex, int tryNumber) { DBTableData data = new DBTableData(); - - try { - int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH)); - if (DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true))) { - Statement st = getConnection().createStatement(); - String query = "select COALESCE(count(*), 0) kolvo from ( select 1 from "+ - escapeNameIfNeeded(schema) + "." + escapeNameIfNeeded(nameTable) + " limit " + (maxRowsCount + 1) + " ) tbl"; - ResultSet rs = st.executeQuery(query); - rs.next(); - if (rs.getInt("kolvo") > maxRowsCount) { - data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); - return data; + try { + final Integer maxRowsCountDefault = DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH); + int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", maxRowsCountDefault); + + final Boolean isFetchLimitedDefault = DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true); + final Boolean isFetchLimited = DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", isFetchLimitedDefault); + + String tableRowsCountQuery = + "select COALESCE(count(*), 0) kolvo " + + "from ( " + + " select 1 from " + escapeNameIfNeeded(schema) + "." + escapeNameIfNeeded(nameTable) + + " limit " + (maxRowsCount + 1) + " " + + ") tbl"; + + if (isFetchLimited) { + try(Statement st = getConnection().createStatement(); ResultSet rs = st.executeQuery(tableRowsCountQuery);){ + if(!rs.next()) { + String msg = "error fetch table rows count"; + throw new ExceptionDBGitRunTime(msg); + } + if (rs.getInt("kolvo") > maxRowsCount) { + data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); + return data; + } } + } int portionSize = DBGitConfig.getInstance().getInteger("core", "PORTION_SIZE", DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000)); - + int begin = 1 + portionSize*portionIndex; int end = portionSize + portionSize*portionIndex; - + + //close statement or I should not? And what if trywithresources?? Statement st = getConnection().createStatement(); String query = " SELECT * FROM \r\n" + " (SELECT f.*, ROW_NUMBER() OVER (ORDER BY ctid) DBGIT_ROW_NUM FROM " + escapeNameIfNeeded(schema) + "." + escapeNameIfNeeded(nameTable) + " f) s\r\n" + " WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end; ResultSet rs = st.executeQuery(query); - - data.setResultSet(rs); + + data.setResultSet(rs); return data; + } catch(Exception e) { ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); logger.error(DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(), e); - + try { - if (tryNumber <= DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000))) { + final Integer tryCountDefault = DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000); + final Integer tryCount = DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", tryCountDefault); + + if (tryNumber <= tryCount) { try { TimeUnit.SECONDS.sleep(DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000))); - } catch (InterruptedException e1) { - throw new ExceptionDBGitRunTime(e1.getMessage()); + } catch (InterruptedException interruptedException) { + throw new ExceptionDBGitRunTime(interruptedException); } + ConsoleWriter.println(DBGitLang.getInstance() .getValue("errors", "dataTable", "loadPortionError") .withParams(String.valueOf(tryNumber)) , messageLevel ); + getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); } } catch (Exception e1) { // TODO Auto-generated catch block e1.printStackTrace(); } - - try { - getConnection().rollback(); - } catch (Exception e2) { - logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); - } - throw new ExceptionDBGitRunTime(e.getMessage()); + + + throw new ExceptionDBGitRunTime(e); } - } - + } + @Override public DBTableData getTableData(String schema, String nameTable) { String tableName = escapeNameIfNeeded(schema)+"."+ escapeNameIfNeeded(nameTable); try { DBTableData data = new DBTableData(); - + int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH)); - + if (DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true))) { Statement st = getConnection().createStatement(); String query = "select COALESCE(count(*), 0) kolvo from ( select 1 from "+ @@ -925,18 +949,18 @@ public DBTableData getTableData(String schema, String nameTable) { data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); return data; } - } + } Statement st = getConnection().createStatement(); ResultSet rs = st.executeQuery("select * from "+tableName); - data.setResultSet(rs); - + data.setResultSet(rs); + //TODO other state - + return data; } catch(Exception e) { logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); try { - getConnection().rollback(); + getConnection().rollback(); } catch (Exception e2) { logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); } @@ -947,20 +971,18 @@ public DBTableData getTableData(String schema, String nameTable) { @Override public Map getUsers() { Map listUser = new HashMap(); - try { - String query = "select *from pg_user"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = "select * from pg_user"; + try (Statement stmt = getConnection().createStatement();ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ String name = rs.getString(1); - DBUser user = new DBUser(name); + StringProperties options = new StringProperties(rs); + + DBUser user = new DBUser(name, options); listUser.put(name, user); } - stmt.close(); - }catch(Exception e) { - logger.error(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); + } catch(Exception e) { + throw new ExceptionDBGitRunTime(e); } //connect.cre //select *from pg_catalog.pg_namespace; @@ -970,33 +992,32 @@ public Map getUsers() { @Override public Map getRoles() { Map listRole = new HashMap(); - try { - String query = - "SELECT r.rolname, r.rolsuper, r.rolinherit,\n" + - " r.rolcreaterole, r.rolcreatedb, r.rolcanlogin, \n" + - " r.rolreplication," + ((getDbVersionNumber() > 9.5) ? "r.rolbypassrls,\n" : "\n") + - " r.rolconnlimit, r.rolpassword, r.rolvaliduntil,\n" + - " ARRAY(SELECT b.rolname\n" + - " FROM pg_catalog.pg_auth_members m\n" + - " JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)\n" + - " WHERE m.member = r.oid) as memberof\n" + - "FROM pg_catalog.pg_roles r\n" + - "WHERE r.rolname !~ '^pg_'\n" + - "ORDER BY 1;"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + String query = + "SELECT r.rolname, r.rolsuper, r.rolinherit,\n" + + " r.rolcreaterole, r.rolcreatedb, r.rolcanlogin, \n" + + " r.rolreplication," + ((getDbVersionNumber() > 9.5) ? "r.rolbypassrls,\n" : "\n") + + " r.rolconnlimit, r.rolpassword, r.rolvaliduntil,\n" + + " ARRAY(SELECT b.rolname\n" + + " FROM pg_catalog.pg_auth_members m\n" + + " JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)\n" + + " WHERE m.member = r.oid) as memberof\n" + + "FROM pg_catalog.pg_roles r\n" + + "WHERE r.rolname !~ '^pg_'\n" + + "ORDER BY 1;"; + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while(rs.next()){ - String name = rs.getString("rolname"); - DBRole role = new DBRole(name); - rowToProperties(rs, role.getOptions()); - listRole.put(name, role); + String name = rs.getString("rolname"); + StringProperties options = new StringProperties(rs); + + DBRole role = new DBRole(name, options); + listRole.put(name, role); } - stmt.close(); - }catch(Exception e) { - logger.error(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); + + } catch(Exception e) { + throw new ExceptionDBGitRunTime(e); } + return listRole; } @@ -1009,23 +1030,23 @@ public boolean userHasRightsToGetDdlOfOtherUsers() { public IFactoryDBBackupAdapter getBackupAdapterFactory() { return backupFactory; } - + @Override public DbType getDbType() { return DbType.POSTGRES; } - + @Override public String getDbVersion() { try { PreparedStatement stmt = getConnection().prepareStatement("SHOW server_version"); - ResultSet resultSet = stmt.executeQuery(); + ResultSet resultSet = stmt.executeQuery(); resultSet.next(); - + String result = resultSet.getString("server_version"); resultSet.close(); stmt.close(); - + return result; } catch (SQLException e) { return ""; @@ -1041,9 +1062,9 @@ public IFactoryDBConvertAdapter getConvertAdapterFactory() { public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit { try { Statement st = connect.createStatement(); - ResultSet rs = st.executeQuery("select count(*) cnt from information_schema.schemata where upper(schema_name) = '" + + ResultSet rs = st.executeQuery("select count(*) cnt from information_schema.schemata where upper(schema_name) = '" + schemaName.toUpperCase() + "'"); - + rs.next(); if (rs.getInt("cnt") == 0) { StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql()); @@ -1057,29 +1078,29 @@ public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit { } catch (SQLException e) { throw new ExceptionDBGit(lang.getValue("errors", "adapter", "createSchema") + ": " + e.getLocalizedMessage()); } - + } @Override public void createRoleIfNeed(String roleName) throws ExceptionDBGit { try { Statement st = connect.createStatement(); - ResultSet rs = st.executeQuery("select count(*) cnt from pg_catalog.pg_roles where upper(rolname) = '" + + ResultSet rs = st.executeQuery("select count(*) cnt from pg_catalog.pg_roles where upper(rolname) = '" + roleName.toUpperCase() + "'"); - + rs.next(); if (rs.getInt("cnt") == 0) { StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql()); stLog.execute("CREATE ROLE " + roleName + " LOGIN PASSWORD '" + roleName + "'"); - + stLog.close(); } - + rs.close(); st.close(); - } catch (SQLException e) { + } catch (SQLException e) { throw new ExceptionDBGit(lang.getValue("errors", "adapter", "createSchema") + ": " + e.getLocalizedMessage()); - } + } } @Override diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java index c086d19..6d1c3ee 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreFunctionPostgres.java @@ -21,8 +21,7 @@ public class DBRestoreFunctionPostgres extends DBRestoreAdapter { public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); - StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); - try { + try(StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql());) { if (obj instanceof MetaFunction) { MetaFunction restoreFunction = (MetaFunction)obj; @@ -74,7 +73,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); } finally { ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - st.close(); } return true; } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 6702bb6..286ee46 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -204,29 +204,28 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { MetaTable existingTable = new MetaTable(restoreTable.getTable()); existingTable.loadFromDB(); - String schema = getPhisicalSchema(restoreTable.getTable().getSchema()); + enrichWithNotNullConstraints(existingTable); + enrichWithNotNullConstraints(restoreTable); MapDifference diff = Maps.difference(existingTable.getConstraints(), restoreTable.getConstraints()); - //drop unneeded + // 0. drop unneeded for(DBConstraint constr : diff.entriesOnlyOnLeft().values()){ - st.execute(MessageFormat.format( - "alter table {0}.{1} drop constraint {2};\n" - , adapter.escapeNameIfNeeded(schema) - , adapter.escapeNameIfNeeded(existingTable.getTable().getName()) - , adapter.escapeNameIfNeeded(constr.getName()) - )); + dropConstraint(existingTable, constr, st); } - // restore not existing - // * not restore index if not exists and have the same named PK + // 1. restore not existing Set typesFirst = Sets.newHashSet("p", "u"); - Comparator pksFirstComparator = Comparator.comparing(x->!typesFirst.contains(x.getConstraintType())); - for(DBConstraint constr : diff.entriesOnlyOnRight().values().stream().sorted(pksFirstComparator).collect(Collectors.toList()) ) { + List newConstraints = diff.entriesOnlyOnRight().values().stream() + .sorted(Comparator.comparing( x -> !typesFirst.contains(x.getConstraintType()) )) + .collect(Collectors.toList()); + + for(DBConstraint constr : newConstraints) { + // * * * not restore index if not exists and have the same named PK createConstraint(restoreTable, constr, st, false /* * */); } - //process intersects + // 2. process intersects for (ValueDifference constr : diff.entriesDiffering().values()){ //MapDifference propsDiff = Maps.difference(constr.leftValue().getOptions().getChildren(), constr.leftValue().getOptions().getChildren()); //ConsoleWriter.printlnColor("Difference in constraints: " + propsDiff.toString(), Ansi.FColor.MAGENTA, 1); @@ -247,6 +246,28 @@ public void restoreTableConstraintPostgres(IMetaObject obj) throws Exception { st.close(); } } + + private void dropConstraint(MetaTable existingTable, DBConstraint constr, StatementLogging st) throws SQLException, ExceptionDBGit { + String schema = getPhisicalSchema(existingTable.getTable().getSchema()); + String name = existingTable.getTable().getName(); + + if(constr.getConstraintType().equals("nn")){ + st.execute(MessageFormat.format( + "ALTER TABLE {0}.{1} ALTER {2} DROP NOT NULL;\n" + , adapter.escapeNameIfNeeded(schema) + , adapter.escapeNameIfNeeded(name) + , adapter.escapeNameIfNeeded(constr.getOptions().get("column_name").getData()) + )); + } else { + st.execute(MessageFormat.format( + "ALTER TABLE {0}.{1} DROP CONSTRAINT {2};\n" + , adapter.escapeNameIfNeeded(schema) + , adapter.escapeNameIfNeeded(name) + , adapter.escapeNameIfNeeded(constr.getName()) + )); + } + } + private NameMeta getEscapedNameMeta(MetaTable table) throws ExceptionDBGit { NameMeta nm = new NameMeta(); String schema = adapter.escapeNameIfNeeded(getPhisicalSchema(table.getTable().getSchema().toLowerCase())); @@ -336,11 +357,11 @@ && hasNotTypeSql(tblField, "text") ); } } - private void createTable(StatementLogging st, MetaTable restoreTable) throws SQLException, ExceptionDBGit { + private void createTable(StatementLogging st, MetaTable restoreTable) throws Exception { NameMeta nme = getEscapedNameMeta(restoreTable); String createTableDdl = MessageFormat.format( - "create table {0}.{1}() {2};\n alter table {0}.{1} owner to {3}" + "create table {0}.{1}() {2};" ,nme.getSchema() ,nme.getName() ,restoreTable.getTable().getOptions().getChildren().containsKey("tablespace") @@ -468,22 +489,33 @@ private void restoreTablePartition(MetaTable restoreTable, Statement st) throws //TODO restoreTableConstraintPostgres private void createConstraint(MetaTable restoreTable, DBConstraint constr, StatementLogging st, boolean replaceExisting) throws Exception { + //dont create constraint on table with 'parent' key + if (restoreTable.getTable().getOptions().getChildren().containsKey("parent")) return; + NameMeta nme = getEscapedNameMeta(restoreTable); - String tblSam = nme.getSchema()+"."+nme.getName(); - String constrName = adapter.escapeNameIfNeeded(constr.getName()); - String constrDdl = (replaceExisting) ? MessageFormat.format("alter table {0} drop constraint {1};\n", tblSam, constrName) : ""; - constrDdl += MessageFormat.format( - "alter table {0} add constraint {1} {2};\n" - ,tblSam - ,constrName - ,constr.getSql() - .replace(" " + constr.getSchema() + ".", " " + nme.getSchema() + ".") - .replace("REFERENCES ", "REFERENCES " + nme.getSchema() + ".") - ); + String tblSam = getPhisicalSchema(nme.getSchema())+"."+nme.getName(); + String constrDdl; + + if(constr.getConstraintType().equals("nn")){ + constrDdl = MessageFormat.format("ALTER TABLE {0} {1};\n", tblSam, constr.getSql()); + + } else { + String constrName = adapter.escapeNameIfNeeded(constr.getName()); + + constrDdl = (replaceExisting) + ? MessageFormat.format("ALTER TABLE {0} DROP CONSTRAINT {1};\n", tblSam, constrName) + : ""; + constrDdl += MessageFormat.format( + "ALTER TABLE {0} ADD CONSTRAINT {1} {2};\n" + ,tblSam + ,constrName + ,constr.getSql() + .replace(" " + constr.getSchema() + ".", " " + nme.getSchema() + ".") + .replace("REFERENCES ", "REFERENCES " + nme.getSchema() + ".") + ); + } - //dont create constraint on table with 'parent' key - if (!restoreTable.getTable().getOptions().getChildren().containsKey("parent")) - st.execute(constrDdl); + st.execute(constrDdl); } @@ -491,29 +523,22 @@ private void createConstraint(MetaTable restoreTable, DBConstraint constr, State private void addColumn(String tblSam, DBTableField tblField, Statement st ) throws SQLException { String fieldName = adapter.escapeNameIfNeeded(tblField.getName()); st.execute( - "alter table "+ tblSam +" add column " - + fieldName + " " - + tblField.getTypeSQL().replace("NOT NULL", "") + "alter table "+ tblSam +" add column " + + fieldName + " " + + tblField.getTypeSQL().replace("NOT NULL", "") ); if (tblField.getDescription() != null && tblField.getDescription().length() > 0) st.execute( - "COMMENT ON COLUMN " + tblSam + "." - + fieldName - + " IS '" + tblField.getDescription() + "'" + "COMMENT ON COLUMN " + tblSam + "." + + fieldName + + " IS '" + tblField.getDescription() + "'" ); - if (!tblField.getIsNullable()) { - st.execute( - "alter table " + tblSam - + " alter column " + fieldName - + " set not null" - ); - } if (tblField.getDefaultValue() != null && tblField.getDefaultValue().length() > 0) { st.execute( - "alter table " + tblSam + " alter column " + fieldName - + " SET DEFAULT " + tblField.getDefaultValue() + "alter table " + tblSam + " alter column " + fieldName + + " SET DEFAULT " + tblField.getDefaultValue() ); } @@ -532,19 +557,14 @@ private boolean hasNotTypeSql(ValueDifference field, String typeSq private void alterTypeColumn(String tblSam, ValueDifference tblField, Statement st) throws SQLException { st.execute(MessageFormat.format("ALTER TABLE {0} ALTER COLUMN {1} TYPE {2} USING ({3}::{4})" - , tblSam - , adapter.escapeNameIfNeeded(tblField.leftValue().getName()) - , tblField.leftValue().getTypeSQL().replace("NOT NULL", "") - , adapter.escapeNameIfNeeded(tblField.leftValue().getName()) - , tblField.leftValue().getTypeSQL().replace("NOT NULL", "") + , tblSam + , adapter.escapeNameIfNeeded(tblField.leftValue().getName()) + //NOT NULLs are created and dropped with other constraints as transient DBConstraint instances + , tblField.leftValue().getTypeSQL().replace("NOT NULL", "") + , adapter.escapeNameIfNeeded(tblField.leftValue().getName()) + , tblField.leftValue().getTypeSQL().replace("NOT NULL", "") )); - if (!tblField.leftValue().getIsNullable()) { - st.execute(MessageFormat.format("ALTER TABLE {0} ALTER COLUMN {1} SET NOT NULL" - , tblSam - , adapter.escapeNameIfNeeded(tblField.leftValue().getName()) - )); - } } private void restoreTableFieldComment(String tableSam, ValueDifference tblField, Statement st) throws SQLException { @@ -578,10 +598,10 @@ private void restoreTableFieldDefaultValue(String tableSam, ValueDifference constraints = dbTable.getConstraints(); for(DBConstraint constrs :constraints.values()) { - st.execute( - "alter table "+ adapter.escapeNameIfNeeded(schema) +"."+adapter.escapeNameIfNeeded(table.getTable().getName()) - +" drop constraint if exists "+adapter.escapeNameIfNeeded(constrs.getName()) - ); + dropConstraint(table, constrs, st); } } else { @@ -652,6 +669,25 @@ private void removeTableConstraintsPostgres(IMetaObject obj) throws Exception { ); } } + + public void enrichWithNotNullConstraints(MetaTable table){ + table.getFields().values().stream() + .filter( field -> field.getIsNullable()) + .map( field -> constructNotNullDBConstraint(table, field)) + .forEach( nnc -> table.getConstraints().put(nnc.getName(), nnc) ); + } + + public DBConstraint constructNotNullDBConstraint(MetaTable table, DBTableField field){ + String name = "notnull_" + field.getName() + " (Transient)"; + String type = "nn"; + DBConstraint constraint = new DBConstraint(name, table.getTable().getSchema(), table.getTable().getOwner(), type); + + constraint.getOptions().getChildren().put("column_name", new StringProperties(field.getName())); + constraint.setSql(MessageFormat.format( + "ALTER COLUMN {0} SET NOT NULL" + , adapter.escapeNameIfNeeded(field.getName())) + ); + return constraint; } /*public void removeIndexesPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java index cf2be3d..82bd4e3 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTriggerPostgres.java @@ -52,9 +52,6 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { )); } - - - } catch (Exception e) { throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), e); diff --git a/src/main/java/ru/fusionsoft/dbgit/utils/StringProperties.java b/src/main/java/ru/fusionsoft/dbgit/utils/StringProperties.java index a71b179..e7cb9ad 100644 --- a/src/main/java/ru/fusionsoft/dbgit/utils/StringProperties.java +++ b/src/main/java/ru/fusionsoft/dbgit/utils/StringProperties.java @@ -1,10 +1,12 @@ package ru.fusionsoft.dbgit.utils; -import java.util.HashMap; +import java.sql.ResultSet; import java.util.Map; +import java.util.Objects; import java.util.TreeMap; import org.apache.commons.lang3.StringUtils; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; /** * Tree string properties @@ -25,6 +27,22 @@ public StringProperties(String data) { this(); this.data = data; } + + public StringProperties (ResultSet rs) { + + try { + for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) { + if (rs.getString(i) == null) continue ; + + String columnName = rs.getMetaData().getColumnName(i); + if (columnName.equalsIgnoreCase("dependencies")) continue ; + + addChild(columnName.toLowerCase(), cleanString(rs.getString(i))); + } + } catch(Exception e) { + throw new ExceptionDBGitRunTime(e); + } + } public StringProperties addChild(String name) { @@ -116,6 +134,34 @@ public String toString() { return toString(0).toString(); } + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + StringProperties that = (StringProperties) o; + if(getData() != null){ + return getData().equals(that.getData()) + && Objects.equals(getChildren(), that.getChildren()); + } else { + return that.getData() == null + && Objects.equals(getChildren(), that.getChildren()); + } + + + } + + @Override + public int hashCode() { + return Objects.hash(getData(), getChildren()); + } + + public String cleanString(String str) { + String dt = str.replace("\r\n", "\n"); + while (dt.contains(" \n")) dt = dt.replace(" \n", "\n"); + dt = dt.replace("\t", " ").trim(); + + return dt; + } } diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index ebf51c1..4835376 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -247,6 +247,8 @@ errors: tables: Error load tables! tableFields: Error load table fields! tableData: Error load table data! + tableSpace: Error load tablespace! + sequence: Error load sequence! index: Error load indexes! constraint: Error load constraints! views: Error load views! From 366d9ec207af2cc4f6b5babca1e1da1aee16b406 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 3 Mar 2021 19:49:50 +0300 Subject: [PATCH 44/68] Finally fix NotNull constraint workaround with Postgres Refactor to stabilize code base --- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 84 +- .../ru/fusionsoft/dbgit/core/DBGitConfig.java | 69 +- .../ru/fusionsoft/dbgit/core/DBGitPath.java | 9 +- .../fusionsoft/dbgit/core/ExceptionDBGit.java | 30 +- .../dbgit/core/ExceptionDBGitRunTime.java | 2 +- .../dbgit/core/ExceptionDBGitTableData.java | 29 + .../dbgit/core/GitMetaDataManager.java | 3 +- .../NotImplementedExceptionDBGitRuntime.java | 7 + .../dbgit/dbobjects/DBOptionsObject.java | 5 +- .../fusionsoft/dbgit/dbobjects/DBSchema.java | 4 + .../fusionsoft/dbgit/dbobjects/DBTable.java | 54 + .../dbgit/dbobjects/DBTableData.java | 58 +- .../dbgit/dbobjects/DBTableField.java | 48 +- .../fusionsoft/dbgit/meta/MetaTableData.java | 24 +- .../dbgit/mssql/DBAdapterMssql.java | 1590 +++++++++-------- .../dbgit/mssql/DBRestoreTableDataMssql.java | 2 +- .../dbgit/mysql/DBAdapterMySql.java | 844 +++++---- .../dbgit/mysql/DBRestoreTableDataMySql.java | 2 +- .../dbgit/oracle/DBAdapterOracle.java | 936 +++++----- .../oracle/DBRestoreTableDataOracle.java | 10 +- .../dbgit/postgres/DBAdapterPostgres.java | 496 +++-- .../postgres/DBRestoreTableDataPostgres.java | 2 +- .../postgres/DBRestoreTablePostgres.java | 14 +- .../dbgit/utils/StringProperties.java | 66 +- .../dbgit/yaml/DBGitYamlConstructor.java | 47 +- src/main/resources/lang/eng.yaml | 4 +- .../java/ru/fusionsoft/dbgit/DBGitTest.java | 483 +++-- .../ru/fusionsoft/dbgit/MetaObjectTest.java | 48 +- .../java/ru/fusionsoft/dbgit/UtilTest.java | 18 +- .../dbgit/mssql/DBAdapterMssqlTest.java | 112 +- src/test/resources/repo | 2 +- 31 files changed, 2769 insertions(+), 2333 deletions(-) create mode 100644 src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitTableData.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/core/NotImplementedExceptionDBGitRuntime.java diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index 2b7a2c8..b245496 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -1,12 +1,11 @@ package ru.fusionsoft.dbgit.core; import java.io.File; -import java.text.MessageFormat; +import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Set; -import com.diogonunes.jcdp.color.api.Ansi; import org.eclipse.jgit.api.*; import org.eclipse.jgit.api.ListBranchCommand.ListMode; import org.eclipse.jgit.api.ResetCommand.ResetType; @@ -29,81 +28,80 @@ import ru.fusionsoft.dbgit.utils.MaskFilter; public class DBGit { - private static DBGit dbGit = null; - private Repository repository; - private Git git; - private static int messageLevel = 0; + private static DBGit instance; + final private Repository repository; + final private Git git; + final private static int messageLevel = 0; - private DBGit() throws ExceptionDBGit { + private DBGit() { try { FileRepositoryBuilder builder = new FileRepositoryBuilder(); repository = builder - .readEnvironment() // scan environment GIT_* variables - .findGitDir() // scan up the file system tree - .build(); + .readEnvironment() // scan environment GIT_* variables + .findGitDir() // scan up the file system tree + .build(); git = new Git(repository); - } catch (Exception e) { - throw new ExceptionDBGit(e); + instance = this; + } catch (IOException e) { + final String msg = "Could not build file repository, never intended to do anything after that..."; + throw new ExceptionDBGitRunTime(msg, e); } + } - private DBGit(String url) throws ExceptionDBGit { + private DBGit(String url) { try { + //TODO find out where this 'url' is in 'repository' FileRepositoryBuilder builder = new FileRepositoryBuilder(); repository = builder - .setGitDir(new File(url)) - .build(); + .setGitDir(new File(url)) + .build(); git = new Git(repository); } catch (Exception e) { - throw new ExceptionDBGit(e); + throw new ExceptionDBGitRunTime(e); } } - public static DBGit getInstance() throws ExceptionDBGit { - if (dbGit == null) { - FileRepositoryBuilder builder = new FileRepositoryBuilder(); + public static DBGit getInstance() { + if (instance == null) { - if (builder.readEnvironment().findGitDir().getGitDir() == null) { - throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "gitRepNotFound")); + if (!repositoryExists()) { + final DBGitLang msg = DBGitLang.getInstance().getValue("errors", "gitRepNotFound"); + throw new ExceptionDBGitRunTime(msg); } - dbGit = new DBGit(); + instance = new DBGit(); } - return dbGit; + return instance; } - public static DBGit initUrlInstance(String gitDirUrl, boolean force) throws ExceptionDBGit { - if (dbGit != null && !force) { - throw new ExceptionDBGit("Already initialized"); - } - dbGit = new DBGit(gitDirUrl); - return dbGit; + public static void initUrlInstance(String gitDirUrl, boolean force) { + if (instance != null) { + if(!force) { + final String msg = "DBGit is already initialized, btw u can set 'force' to 'true' or never make singletons..."; + throw new ExceptionDBGitRunTime(msg); + } + instance.repository.close(); + instance.git.close(); + instance = new DBGit(gitDirUrl); + } } - public static boolean checkIfRepositoryExists() throws ExceptionDBGit { - if (dbGit == null) { + public static boolean repositoryExists() { + if (instance == null) { FileRepositoryBuilder builder = new FileRepositoryBuilder(); - - if (builder.readEnvironment().findGitDir().getGitDir() == null) { - return false; - } else { - return true; - } - - } else - return true; + return builder.readEnvironment().findGitDir().getGitDir() != null; + } + else return true; } public Repository getRepository() { return repository; } - public void setRepository(Repository repository) { - this.repository = repository; - } public String getRootDirectory() { return repository.getDirectory().getParent(); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java index 726ceac..2b2eb0f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java @@ -2,6 +2,7 @@ import java.io.File; import java.io.IOException; +import java.net.URISyntaxException; import java.util.HashMap; import java.util.Map; @@ -16,16 +17,25 @@ public class DBGitConfig { private Ini iniGlobal = null; private Map transientConfig = new HashMap<>(); - private DBGitConfig() throws Exception { - - if (DBGit.checkIfRepositoryExists()) { - File file = new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG); - if (file.exists()) - ini = new Ini(file); + private DBGitConfig() { + try{ + findAndSetIni(); + findAndSetIniGlobal(); + } catch (Exception anyKindOfException){ + //no reason to continue anything + throw new ExceptionDBGitRunTime(anyKindOfException); } + } - String path = new File(DBGitConfig.class.getProtectionDomain().getCodeSource().getLocation() - .toURI()).getAbsolutePath(); + public static DBGitConfig getInstance() { + if (config == null) config = new DBGitConfig(); + return config; + } + + private void findAndSetIniGlobal() throws URISyntaxException, IOException { + String path = new File(DBGitConfig.class.getProtectionDomain() + .getCodeSource().getLocation().toURI() + ).getAbsolutePath(); //for debug: if (path.contains("classes")) path = path + "/../dbgit"; @@ -43,49 +53,47 @@ private DBGitConfig() throws Exception { path = path + "/dbgitconfig"; File fileGlobal = new File(path); - if (fileGlobal.exists()) - iniGlobal = new Ini(fileGlobal); + if (fileGlobal.exists()) iniGlobal = new Ini(fileGlobal); } - public static DBGitConfig getInstance() throws Exception { - if (config == null) - config = new DBGitConfig(); + private void findAndSetIni() throws IOException { + if (DBGit.repositoryExists()) { + File file = new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG); + if (file.exists()) ini = new Ini(file); + } + } - return config; + private Ini getIni() throws IOException { + if(ini == null){ + findAndSetIni(); + } + return ini; } public String getString(String section, String option, String defaultValue) { return getString(section, option, defaultValue, false); } - public Boolean getBoolean(String section, String option, Boolean defaultValue) { return getBoolean(section, option, defaultValue, false); } - public Integer getInteger(String section, String option, Integer defaultValue) { return getInteger(section, option, defaultValue, false); } - public Double getDouble(String section, String option, Double defaultValue) { return getDouble(section, option, defaultValue, false); } - public String getStringGlobal(String section, String option, String defaultValue) { return getString(section, option, defaultValue, true); } - public Boolean getBooleanGlobal(String section, String option, Boolean defaultValue) { return getBoolean(section, option, defaultValue, true); } - public Integer getIntegerGlobal(String section, String option, Integer defaultValue) { return getInteger(section, option, defaultValue, true); } - public Double getDoubleGlobal(String section, String option, Double defaultValue) { return getDouble(section, option, defaultValue, true); } - private String getString(String section, String option, String defaultValue, boolean global) { try { String result = global ? iniGlobal.get(section, option) : getIni().get(section, option); @@ -94,18 +102,6 @@ private String getString(String section, String option, String defaultValue, boo return defaultValue; } } - - private Ini getIni() throws ExceptionDBGit, IOException { - if(ini == null){ - if (DBGit.checkIfRepositoryExists()) { - File file = new File(DBGitPath.getFullPath() + "/" + DBGitPath.DBGIT_CONFIG); - if (file.exists()) - ini = new Ini(file); - } - } - return ini; - } - private Boolean getBoolean(String section, String option, Boolean defaultValue, boolean global) { try { String result = global ? iniGlobal.get(section, option) : getIni().get(section, option); @@ -115,7 +111,6 @@ private Boolean getBoolean(String section, String option, Boolean defaultValue, return defaultValue; } } - private Integer getInteger(String section, String option, Integer defaultValue, boolean global) { try { String result = global ? iniGlobal.get(section, option) : getIni().get(section, option); @@ -124,7 +119,6 @@ private Integer getInteger(String section, String option, Integer defaultValue, return defaultValue; } } - private Double getDouble(String section, String option, Double defaultValue, boolean global) { try { String result = global ? iniGlobal.get(section, option) : getIni().get(section, option); @@ -133,15 +127,12 @@ private Double getDouble(String section, String option, Double defaultValue, boo return defaultValue; } } - public void setValue(String parameter, String value) throws ExceptionDBGit { setValue(parameter, value, false); } - public void setValueGlobal(String parameter, String value) throws ExceptionDBGit { setValue(parameter, value, true); } - public void setValue(String parameter, String value, boolean global) throws ExceptionDBGit { try { if (global) { diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java index 5955f51..437f33b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitPath.java @@ -5,16 +5,11 @@ import java.sql.DriverManager; import java.text.SimpleDateFormat; import java.util.Calendar; -import java.util.Date; import java.util.GregorianCalendar; import java.util.Properties; -import java.util.stream.Stream; - -import javax.print.attribute.standard.DateTimeAtCompleted; import ru.fusionsoft.dbgit.adapters.AdapterFactory; import ru.fusionsoft.dbgit.meta.DBGitMetaType; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.Convertor; /** @@ -89,7 +84,7 @@ public static String getScriptsPath() throws ExceptionDBGit { return dbGit.getRootDirectory()+"/" + DB_GIT_PATH + "/" + SCRIPT_PATH + "/"; } - public static String getFullPath() throws ExceptionDBGit { + public static String getFullPath() { DBGit dbGit = DBGit.getInstance(); return dbGit.getRootDirectory()+"/"+DB_GIT_PATH + "/"; } @@ -100,7 +95,7 @@ public static String getRootPath(String path) throws ExceptionDBGit { } public static boolean isRepositoryExists() throws ExceptionDBGit { - return DBGit.checkIfRepositoryExists(); + return DBGit.repositoryExists(); } public static String getRootPath() throws ExceptionDBGit { diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java index efa1fa0..087d1a1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java @@ -18,22 +18,24 @@ public class ExceptionDBGit extends Exception { private static final long serialVersionUID = -4613368557825624023L; - protected Logger logger = LoggerUtil.getLogger(this.getClass()); - protected static int messageLevel = 0; - private Throwable cause = null; - private String contextMessage = null; + protected static final int messageLevel = 0; + protected final Logger logger = LoggerUtil.getLogger(this.getClass()); + private final Throwable cause; + private final String contextMessage; public ExceptionDBGit(Object msg) { - this.setContextMessage(msg.toString()); + this.contextMessage = msg.toString(); + this.cause = null; handleException(); } public ExceptionDBGit(Object message, Throwable cause) { - this.setContextMessage(message.toString()); - this.setCause(cause); + this.contextMessage = message.toString(); + this.cause = cause; handleException(); } public ExceptionDBGit(Throwable cause) { - this.setCause(cause); + this.cause = cause; + this.contextMessage = ""; handleException(); } @@ -42,9 +44,8 @@ private void handleException(){ rollbackConnection(); System.exit(1); } - - public void printMessageAndStackTrace(){ - if(contextMessage != null && (cause == null || !cause.getMessage().equals(contextMessage))) { + protected void printMessageAndStackTrace(){ + if(!contextMessage.isEmpty() && (cause == null || !cause.getMessage().equals(contextMessage))) { ConsoleWriter.printlnRed(contextMessage, messageLevel); ConsoleWriter.printLineBreak(); } @@ -53,11 +54,11 @@ public void printMessageAndStackTrace(){ ConsoleWriter.printlnRed(cause.getLocalizedMessage(), messageLevel); ConsoleWriter.printLineBreak(); ConsoleWriter.detailsPrintlnRed(ExceptionUtils.getStackTrace(cause), messageLevel); - logger.error(contextMessage != null ? contextMessage : cause.getMessage(), cause); + logger.error(!contextMessage.isEmpty() ? contextMessage : cause.getMessage(), cause); } else { ConsoleWriter.detailsPrintlnRed(ExceptionUtils.getStackTrace(this), messageLevel); - logger.error(contextMessage != null ? contextMessage : "no error message provided..." , this); + logger.error(!contextMessage.isEmpty() ? contextMessage : "no error message provided..." , this); } } private void rollbackConnection() { @@ -81,7 +82,4 @@ private void rollbackConnection() { } } - public void setCause(Throwable cause) { this.cause = cause; } - public void setContextMessage(String contextMessage) { this.contextMessage = contextMessage; } - } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java index e80bfaf..04ff5e2 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java @@ -19,7 +19,7 @@ public ExceptionDBGitRunTime(Object msg) { public ExceptionDBGitRunTime(Object message, Throwable cause) { super(message.toString(), cause); - exceptionDBGit = new ExceptionDBGit(this); + exceptionDBGit = new ExceptionDBGit(message, this); } public ExceptionDBGitRunTime(Throwable cause) { diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitTableData.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitTableData.java new file mode 100644 index 0000000..9bd2cc8 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitTableData.java @@ -0,0 +1,29 @@ +package ru.fusionsoft.dbgit.core; + +public class ExceptionDBGitTableData extends Exception{ + private int errorFlag; + + public ExceptionDBGitTableData(int errorFlag) { + this.errorFlag = errorFlag; + } + + public ExceptionDBGitTableData(String message, int errorFlag) { + super(message); + this.errorFlag = errorFlag; + } + + public ExceptionDBGitTableData(String message, Throwable cause, int errorFlag) { + super(message, cause); + this.errorFlag = errorFlag; + } + + public ExceptionDBGitTableData(Throwable cause, int errorFlag) { + super(cause); + this.errorFlag = errorFlag; + } + + public ExceptionDBGitTableData(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, int errorFlag) { + super(message, cause, enableSuppression, writableStackTrace); + this.errorFlag = errorFlag; + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java index dca494b..a791bd6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java @@ -181,7 +181,8 @@ public IMapMetaObject loadDBMetaData(boolean includeBackupSchemas) throws Except } else { schemes = new HashMap(); try { - schemes.put(adapter.getConnection().getSchema(), new DBSchema(adapter.getConnection().getSchema())); + final DBSchema dbSchema = new DBSchema(adapter.getConnection().getSchema()); + schemes.put(adapter.getConnection().getSchema(), dbSchema); ConsoleWriter.println(DBGitLang.getInstance().getValue("errors", "meta", "cantGetOtherUsersObjects"), messageLevel); } catch (SQLException e) { throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "meta", "cantGetCurrentSchema").toString(), e); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/NotImplementedExceptionDBGitRuntime.java b/src/main/java/ru/fusionsoft/dbgit/core/NotImplementedExceptionDBGitRuntime.java new file mode 100644 index 0000000..4356f0a --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/core/NotImplementedExceptionDBGitRuntime.java @@ -0,0 +1,7 @@ +package ru.fusionsoft.dbgit.core; + +public class NotImplementedExceptionDBGitRuntime extends ExceptionDBGitRunTime { + public NotImplementedExceptionDBGitRuntime(){ + super("Stub class can not use this method"); + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBOptionsObject.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBOptionsObject.java index 87df219..ab9106b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBOptionsObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBOptionsObject.java @@ -16,7 +16,10 @@ public class DBOptionsObject implements IDBObject { @YamlOrder(99) StringProperties options; - + public DBOptionsObject(String name) { + this.name = name; + this.options = new StringProperties(); + } public DBOptionsObject(String name, StringProperties options) { this.name = name; this.options = options; diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchema.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchema.java index 2528b9a..18ace79 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchema.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchema.java @@ -7,4 +7,8 @@ public class DBSchema extends DBOptionsObject { public DBSchema(String name, StringProperties options) { super(name, options); } + + public DBSchema(String name) { + super(name); + } } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java index 25a0ad7..4fe4da7 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java @@ -1,9 +1,11 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.core.NotImplementedExceptionDBGitRuntime; import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.utils.StringProperties; import ru.fusionsoft.dbgit.yaml.YamlOrder; +import java.util.Collections; import java.util.Set; public class DBTable extends DBSchemaObject { @@ -40,4 +42,56 @@ public String getComment() { return this.comment; } + public static class OnlyNamesDBTable extends DBTable{ + + public OnlyNamesDBTable(String name, String schema) { + super(name, new StringProperties(), schema, "", Collections.emptySet(), ""); + } + + @Override + public String getHash() { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public void setComment(String comment) { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public String getComment() { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public Set getDependencies() { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public void setDependencies(Set dependencies) { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public String getOwner() { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public void setOwner(String owner) { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public StringProperties getOptions() { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public void setOptions(StringProperties opt) { + throw new NotImplementedExceptionDBGitRuntime(); + } + } + } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableData.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableData.java index 6d4fedd..affce1d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableData.java @@ -1,30 +1,58 @@ package ru.fusionsoft.dbgit.dbobjects; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; +import ru.fusionsoft.dbgit.core.ExceptionDBGitTableData; + +import java.io.Closeable; +import java.sql.Connection; import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; -public class DBTableData { +public class DBTableData implements AutoCloseable, Closeable { public static final int ERROR_LIMIT_ROWS = 1; - protected int errorFlag = 0; - protected ResultSet resultSet; - - public int getErrorFlag() { - return errorFlag; - } + final protected int errorFlag ; + final protected ResultSet resultSet; + final protected Statement statement; - public void setErrorFlag(int errorFlag) { + public DBTableData(Connection connection, String query) throws SQLException { + this.errorFlag = 0; + this.statement = connection.createStatement(); + this.resultSet = statement.executeQuery(query); + } + public DBTableData(int errorFlag) { this.errorFlag = errorFlag; + this.resultSet = null; + this.statement = null; } - + public int errorFlag() { + return errorFlag; + } + public ResultSet resultSet() throws ExceptionDBGitTableData { - public ResultSet getResultSet() { return resultSet; +// TODO find usages and adapt to recover from the ExceptionDBGitTableData +// if(resultSet != null){ +// return resultSet; +// } else { +// final String msg = DBGitLang.getInstance() +// .getValue("errors", "dataTable", "errorTableData") +// .withParams(String.valueOf(errorFlag)); +// +// throw new ExceptionDBGitTableData(msg, errorFlag); +// } } - public void setResultSet(ResultSet resultSet) { - this.resultSet = resultSet; + + @Override + public void close() { + try{ + this.resultSet.close(); + this.statement.close(); + } catch (SQLException ex){ + throw new ExceptionDBGitRunTime(ex); + } } - - -} +} \ No newline at end of file diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java index 2938994..f00ba0c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java @@ -1,26 +1,52 @@ package ru.fusionsoft.dbgit.dbobjects; -import org.apache.http.annotation.Obsolete; import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.utils.CalcHash; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; +import ru.fusionsoft.dbgit.yaml.YamlOrder; import java.util.Objects; public class DBTableField implements IDBObject, Comparable { + + @YamlOrder(0) private String name; + @YamlOrder(1) private String description; + @YamlOrder(2) + private Boolean isPrimaryKey; + @YamlOrder(3) + private Boolean isNullable; + @YamlOrder(4) private String typeSQL; + @YamlOrder(5) private FieldType typeUniversal; + @YamlOrder(6) + private Integer order; + @YamlOrder(7) + private String defaultValue; + @YamlOrder(8) private int length; + @YamlOrder(9) private int scale; + @YamlOrder(10) private int precision; + @YamlOrder(11) private boolean fixed; - private Integer order = 0; - private Boolean isNullable; - private Boolean isNameExactly = false; - private String defaultValue; - private Boolean isPrimaryKey = false; + + public DBTableField(String name, String description, Boolean isPrimaryKey, Boolean isNullable, String typeSQL, FieldType typeUniversal, Integer order, String defaultValue, int length, int scale, int precision, boolean fixed) { + this.name = name; + this.description = description; + this.isPrimaryKey = isPrimaryKey; + this.isNullable = isNullable; + this.typeSQL = typeSQL; + this.typeUniversal = typeUniversal; + this.order = order; + this.defaultValue = defaultValue; + this.length = length; + this.scale = scale; + this.precision = precision; + this.fixed = fixed; + } @Override public int compareTo(DBTableField o) { @@ -138,14 +164,6 @@ public Integer getOrder() { return order; } - public void setNameExactly(Boolean isNameExactly) { - this.isNameExactly = isNameExactly; - } - - public Boolean getNameExactly() { - return isNameExactly; - } - public String getDefaultValue() { return this.defaultValue; } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index 1da10a1..40a2843 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -1,13 +1,10 @@ package ru.fusionsoft.dbgit.meta; import java.io.*; -import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; import java.sql.ResultSet; import java.util.ArrayList; -import java.util.Iterator; import java.util.List; -import java.util.Map; import java.util.Set; import java.util.TreeMap; import java.util.concurrent.TimeUnit; @@ -15,25 +12,20 @@ import de.siegmar.fastcsv.reader.CsvParser; import de.siegmar.fastcsv.reader.CsvReader; import de.siegmar.fastcsv.reader.CsvRow; -import org.apache.commons.codec.binary.Base64; import org.apache.commons.csv.CSVFormat; import org.apache.commons.csv.CSVParser; import org.apache.commons.csv.CSVPrinter; import org.apache.commons.csv.CSVRecord; -import org.apache.commons.csv.QuoteMode; - import com.diogonunes.jcdp.color.api.Ansi.FColor; import org.apache.commons.lang3.exception.ExceptionUtils; import org.slf4j.Logger; import ru.fusionsoft.dbgit.adapters.AdapterFactory; import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.DBGit; import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.DBGitLang; -import ru.fusionsoft.dbgit.core.DBGitPath; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.core.GitMetaDataManager; @@ -103,7 +95,7 @@ public void setTable(DBTable table) throws ExceptionDBGit { public void setName(String name) throws ExceptionDBGit { if (table == null) { NameMeta nm = MetaObjectFactory.parseMetaName(name); - table = new DBTable(nm.getName(), nm.getSchema()); + table = new DBTable.OnlyNamesDBTable(nm.getName(), nm.getSchema()); } super.setName(name); @@ -257,11 +249,11 @@ public boolean loadPortionFromDB(int currentPortionIndex, int tryNumber) throws dataTable = adapter.getTableDataPortion(table.getSchema(), table.getName(), currentPortionIndex, 0); - ResultSet rs = dataTable.getResultSet(); + ResultSet rs = dataTable.resultSet(); - if (dataTable.getErrorFlag() > 0) { - ConsoleWriter.printlnColor(DBGitLang.getInstance().getValue("errors", "meta", "tooManyRecords"). - withParams(getName(), String.valueOf(IDBAdapter.MAX_ROW_COUNT_FETCH)), FColor.RED, 0); + if (dataTable.errorFlag() > 0) { + final String tooManyRecordsMsg = DBGitLang.getInstance().getValue("errors", "meta", "tooManyRecords").withParams(getName(), String.valueOf(IDBAdapter.MAX_ROW_COUNT_FETCH)); + ConsoleWriter.printlnColor(tooManyRecordsMsg, FColor.RED, 0); return false; } @@ -302,7 +294,7 @@ public boolean loadPortionFromDB(int currentPortionIndex, int tryNumber) throws throw new ExceptionDBGitRunTime(e1.getMessage()); } ConsoleWriter.println(DBGitLang.getInstance() - .getValue("errors", "dataTable", "loadPortionError") + .getValue("errors", "dataTable", "tryAgain") .withParams(String.valueOf(tryNumber)) , messageLevel ); @@ -330,13 +322,13 @@ public boolean loadFromDB() throws ExceptionDBGit { dataTable = adapter.getTableData(table.getSchema(), table.getName()); - if (dataTable.getErrorFlag() > 0) { + if (dataTable.errorFlag() > 0) { ConsoleWriter.printlnColor(DBGitLang.getInstance().getValue("errors", "meta", "tooManyRecords"). withParams(getName(), String.valueOf(IDBAdapter.MAX_ROW_COUNT_FETCH)), FColor.RED, 0); return false; } - ResultSet rs = dataTable.getResultSet(); + ResultSet rs = dataTable.resultSet(); mapRows = new TreeMapRowData(); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java index b964d5c..7b48321 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java @@ -1,22 +1,23 @@ package ru.fusionsoft.dbgit.mssql; +import com.google.common.collect.ImmutableMap; +import org.apache.commons.lang3.exception.ExceptionUtils; import org.slf4j.Logger; import ru.fusionsoft.dbgit.adapters.DBAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBAdapterRestoteMetaData; import ru.fusionsoft.dbgit.adapters.IFactoryDBBackupAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; -import ru.fusionsoft.dbgit.core.DBGitConfig; -import ru.fusionsoft.dbgit.core.DBGitLang; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; +import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.data_table.*; import ru.fusionsoft.dbgit.dbobjects.*; import ru.fusionsoft.dbgit.meta.IMapMetaObject; +import ru.fusionsoft.dbgit.meta.TreeMapMetaObject; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; +import ru.fusionsoft.dbgit.utils.StringProperties; import java.sql.*; import java.util.*; @@ -27,18 +28,18 @@ public class DBAdapterMssql extends DBAdapter { public static final String DEFAULT_MAPPING_TYPE = "varchar"; private static final HashSet systemSchemas = new HashSet<>(Arrays.asList( - "db_denydatawriter", - "db_datawriter", - "db_accessadmin", - "db_ddladmin", - "db_securityadmin", - "db_denydatareader", - "db_backupoperator", - "db_datareader", - "db_owner", - "sys", - "INFORMATION_SCHEMA" - )); + "db_denydatawriter", + "db_datawriter", + "db_accessadmin", + "db_ddladmin", + "db_securityadmin", + "db_denydatareader", + "db_backupoperator", + "db_datareader", + "db_owner", + "sys", + "INFORMATION_SCHEMA" + )); //Stubs for MSSQL adapter, marked as "TODO Auto-generated method stub" //And some unfinished implementations marked as "TODO MSSQL *" @@ -65,33 +66,30 @@ public void endUpdateDB() { @Override public IMapMetaObject loadCustomMetaObjects() { - // TODO Auto-generated method stub - return null; + return new TreeMapMetaObject(Collections.emptyList()); } @Override public Map getSchemes() { - Map listScheme = new HashMap(); - try { - Connection connect = getConnection(); - DatabaseMetaData meta = connect.getMetaData(); - ResultSet rs = meta.getSchemas(); + final Map listScheme = new HashMap<>(); + try (ResultSet rs = getConnection().getMetaData().getSchemas()){ + // made without query // Statement stmt = connect.createStatement(); // ResultSet rs = stmt.executeQuery(query); while(rs.next()){ + final String name = rs.getString("TABLE_SCHEM"); + // May also get catalog names that belong to scheme as "TABLE_CATALOG" - String name = rs.getString("TABLE_SCHEM"); if(!systemSchemas.contains(name)) { - DBSchema scheme = new DBSchema(name); - rowToProperties(rs, scheme.getOptions()); + final DBSchema scheme = new DBSchema(name, new StringProperties(rs)); listScheme.put(name, scheme); } } - //stmt.close(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "schemes").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "schemes").toString(), e); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "schemes").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listScheme; @@ -99,8 +97,8 @@ public Map getSchemes() { @Override public Map getTableSpaces() { - - String query = "SELECT \n" + + final Map listTableSpace = new HashMap<>(); + final String query = "SELECT \n" + "[SFG].name AS [File Group Name],\n" + "[SFG].*,\n" + "[SDB].name AS [Database Name],\n" + @@ -159,502 +157,521 @@ public Map getTableSpaces() { " [filegroup_guid],\n" + " [log_filegroup_id]\n" + "DROP TABLE #fgroups\n"; - Map listTableSpace = new HashMap(); - try { - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ - String name = rs.getString("File Group Name"); - DBTableSpace dbTableSpace = new DBTableSpace(name); - rowToProperties(rs, dbTableSpace.getOptions()); + final String name = rs.getString("File Group Name"); + final DBTableSpace dbTableSpace = new DBTableSpace(name, new StringProperties(rs)); listTableSpace.put(name, dbTableSpace); } - stmt.close(); - }catch(Exception e) { - logger.error(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); - } - return listTableSpace; - } - private DBSequence sequenceFromResultSet(ResultSet rs, String schema){ - try { - String nameSeq = rs.getString("name"); - Long valueSeq = rs.getLong("current_value"); - DBSequence sequence = new DBSequence(); - sequence.setName(nameSeq); - sequence.setSchema(schema); - sequence.setValue(valueSeq); - rowToProperties(rs, sequence.getOptions()); - return sequence; - } catch (Exception ex){ - logger.error(ex.getMessage(), ex); - throw new ExceptionDBGitRunTime(ex.getMessage(), ex); + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "tablespace").toString(); + throw new ExceptionDBGitRunTime(msg, e); } + + return listTableSpace; } @Override public Map getSequences(String schema) { - Map listSequence = new HashMap(); - try { - Connection connect = getConnection(); - String query = - "SELECT seq.*,\n" + - "TYPE_NAME(seq.system_type_id) as typeName,\n" + - "SCHEMA_NAME(seq.schema_id) as owner \n" + - "FROM sys.objects, sys.SEQUENCES seq \n" + - "WHERE sys.objects.object_id = seq.object_id \n" + - "AND SCHEMA_NAME(seq.schema_id) = '"+schema+"'"; + final Map listSequence = new HashMap(); + final String query = + "SELECT seq.*,\n" + + "TYPE_NAME(seq.system_type_id) as typeName,\n" + + "SCHEMA_NAME(seq.schema_id) as owner \n" + + "FROM sys.objects, sys.SEQUENCES seq \n" + + "WHERE sys.objects.object_id = seq.object_id \n" + + "AND SCHEMA_NAME(seq.schema_id) = '"+schema+"'"; + + try(Statement stmtValue = getConnection().createStatement(); ResultSet rs = stmtValue.executeQuery(query)){ - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); while(rs.next()){ - String nameSeq = rs.getString("name"); - listSequence.put(nameSeq, sequenceFromResultSet(rs, schema)); + final String ownerSeq = "dbo"; + final String nameSeq = rs.getString("name"); + final Long valueSeq = rs.getLong("current_value"); + final DBSequence seq = new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); + listSequence.put(nameSeq, seq); } - stmt.close(); - }catch(Exception e) { - logger.error(e.getMessage(), e); - throw new ExceptionDBGitRunTime(e.getMessage(), e); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "seq").toString(); + throw new ExceptionDBGitRunTime(msg, e); } + return listSequence; } @Override public DBSequence getSequence(String schema, String name) { - try { - Connection connect = getConnection(); - String query = - "SELECT seq.*,\n" + - "USER_NAME(objectproperty(seq.object_id,'OwnerId')) as owner,\n" + - "TYPE_NAME(seq.system_type_id) as typeName, " + - "SCHEMA_NAME(seq.schema_id) as schemaName " + - "FROM sys.objects, sys.SEQUENCES seq " + - "WHERE sys.objects.object_id = seq.object_id " + - "AND SCHEMA_NAME(seq.schema_id) = '"+schema+"' " + - "AND seq.name = '" + name + "'\n"; - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); + final String query = + "SELECT seq.*,\n" + + "USER_NAME(objectproperty(seq.object_id,'OwnerId')) as owner,\n" + + "TYPE_NAME(seq.system_type_id) as typeName, " + + "SCHEMA_NAME(seq.schema_id) as schemaName " + + "FROM sys.objects, sys.SEQUENCES seq " + + "WHERE sys.objects.object_id = seq.object_id " + + "AND SCHEMA_NAME(seq.schema_id) = '"+schema+"' " + + "AND seq.name = '" + name + "'\n"; + + try(Statement stmtValue = getConnection().createStatement(); ResultSet rs = stmtValue.executeQuery(query)){ + + if(rs.next()){ + final String ownerSeq = "dbo"; + final String nameSeq = rs.getString("name"); + final Long valueSeq = rs.getLong("current_value"); + return new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); + } else { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } - DBSequence sequence = null; - while (rs.next()) { - sequence = sequenceFromResultSet(rs, schema); - } - stmt.close(); - return sequence; - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "sequences").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "sequences").toString(), e); + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "seq").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public Map getTables(String schema) { - Map listTable = new HashMap(); - try { - String query = - "SELECT TABLE_NAME as 'name', TABLE_CATALOG as 'database', TABLE_SCHEMA as 'schema'\n" + - "FROM INFORMATION_SCHEMA.TABLES \n" + - "WHERE INFORMATION_SCHEMA.TABLES.TABLE_SCHEMA = '" + schema + "'\n" + - "AND INFORMATION_SCHEMA.TABLES.TABLE_TYPE = 'BASE TABLE'"; - Connection connect = getConnection(); - - Statement stmt = connect.createStatement(); - ResultSet rs = stmt.executeQuery(query); - + final Map listTable = new HashMap<>(); + final String query = + "SELECT TABLE_NAME as 'name', TABLE_CATALOG as 'database', TABLE_SCHEMA as 'schema'\n" + + "FROM INFORMATION_SCHEMA.TABLES \n" + + "WHERE INFORMATION_SCHEMA.TABLES.TABLE_SCHEMA = '" + schema + "'\n" + + "AND INFORMATION_SCHEMA.TABLES.TABLE_TYPE = 'BASE TABLE'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ - String nameTable = rs.getString("name"); - DBTable table = new DBTable(nameTable, schema); - rowToProperties(rs, table.getOptions()); + //TODO retrieve table comment + //TODO retrieve table owner + final String nameTable = rs.getString("name"); + final String ownerTable = ""; + final String commentTable = ""; + final StringProperties options = new StringProperties(rs); + final Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); + + final DBTable table = new DBTable(nameTable, options, schema, ownerTable, dependencies, commentTable); listTable.put(nameTable, table); } - stmt.close(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listTable; } @Override public DBTable getTable(String schema, String name) { - DBTable table = null; - try(Statement stmt = getConnection().createStatement()) { - String query = - "SELECT\n" + - " o.name tableName, t.TABLE_SCHEMA schemaName, t.TABLE_CATALOG catalogName,\n" + - " CASE WHEN o.principal_id is NOT NULL THEN (SELECT name FROM sys.database_principals dp WHERE dp.principal_id=o.principal_id)\n" + - " ELSE (SELECT dp.name FROM sys.database_principals dp,sys.schemas s WHERE s.schema_id=o.schema_id and s.principal_id=dp.principal_id)\n" + - " END as owner\n" + - "FROM sys.objects o, INFORMATION_SCHEMA.TABLES t\n" + - "WHERE o.type='U' AND o.name = t.TABLE_NAME AND t.TABLE_NAME = '"+name+"' AND t.TABLE_SCHEMA = '"+schema+"'"; - - ResultSet rs = stmt.executeQuery(query); + final String query = + "SELECT\n" + + " o.name tableName, t.TABLE_SCHEMA schemaName, t.TABLE_CATALOG catalogName,\n" + + " CASE WHEN o.principal_id is NOT NULL THEN (SELECT name FROM sys.database_principals dp WHERE dp.principal_id=o.principal_id)\n" + + " ELSE (SELECT dp.name FROM sys.database_principals dp,sys.schemas s WHERE s.schema_id=o.schema_id and s.principal_id=dp.principal_id)\n" + + " END as owner\n" + + "FROM sys.objects o, INFORMATION_SCHEMA.TABLES t\n" + + "WHERE o.type='U' AND o.name = t.TABLE_NAME AND t.TABLE_NAME = '"+name+"' AND t.TABLE_SCHEMA = '"+schema+"'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + if (rs.next()){ + //TODO retrieve table comment + //TODO retrieve table owner + final String nameTable = rs.getString("name"); + final String ownerTable = ""; + final String commentTable = ""; + final StringProperties options = new StringProperties(rs); + final Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); + + return new DBTable(nameTable, options, schema, ownerTable, dependencies, commentTable); + } else { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } - while(rs.next()){ - String nameTable = rs.getString("tableName"); - table = new DBTable(nameTable, schema); - rowToProperties(rs, table.getOptions()); - } - return table; - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public Map getTableFields(String schema, String nameTable) { - Map listField = new HashMap<>(); - try(Statement stmt = getConnection().createStatement()) { - String query = - "SELECT DISTINCT\n" + - " c.TABLE_SCHEMA as schemaName,\n" + - " c.TABLE_NAME as tableName,\n" + - " c.COLUMN_NAME as columnName,\n" + - " c.ORDINAL_POSITION as columnOrder,\n" + - " c.DATA_TYPE as mssqlType,\n" + - " CASE WHEN lower(c.DATA_TYPE) in ('bigint', 'int', 'float', 'decimal', 'money', 'numeric', 'real', 'smallint', 'smallmoney', 'tinyint') then 'number' \n" + - " when lower(c.DATA_TYPE) in ('char','varchar','xml','nchar','nvarchar', 'uniqueidentifier') then 'string'\n" + - " when lower(c.DATA_TYPE) in ('bit') then 'boolean'\n" + - " when lower(c.DATA_TYPE) in ('datetime', 'smalldatetime', 'time') then 'date'\n" + - " when lower(c.DATA_TYPE) in ('text','ntext') then 'text'\n" + - " when lower(c.DATA_TYPE) in ('timestamp', 'binary', 'varbinary', 'geometry', 'geography') then 'binary'\n" + - " else 'native'\n" + - " end dbgitType,\n" + - " CASE WHEN 1 IN ( \n" + - " SELECT OBJECTPROPERTY(OBJECT_ID(CONSTRAINT_SCHEMA + '.' + QUOTENAME(CONSTRAINT_NAME)),'IsPrimaryKey')\n" + - " FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE\n" + - " WHERE c.COLUMN_NAME = COLUMN_NAME AND c.TABLE_NAME = TABLE_NAME\n" + - " )\n" + - " THEN 1 ELSE 0 END isPk,\n" + - " c.IS_NULLABLE as isNullable,\n" + - " c.NUMERIC_SCALE as scale,\n" + - " c.CHARACTER_MAXIMUM_LENGTH as length,\n" + - " CASE WHEN lower(c.DATA_TYPE) in ('char', 'nchar') then '1' else '0' end isFixed," + - " c.NUMERIC_PRECISION as precision\n" + - "FROM INFORMATION_SCHEMA.COLUMNS as c\n" + - "WHERE TABLE_SCHEMA = '" + schema + "' AND TABLE_NAME = '" + nameTable + "'"; + final Map listField = new HashMap<>(); + final String query = + "SELECT DISTINCT\n" + + " c.TABLE_SCHEMA as schemaName,\n" + + " c.TABLE_NAME as tableName,\n" + + " c.COLUMN_NAME as columnName,\n" + + " c.ORDINAL_POSITION as columnOrder,\n" + + " c.DATA_TYPE as mssqlType,\n" + + " CASE WHEN lower(c.DATA_TYPE) in ('bigint', 'int', 'float', 'decimal', 'money', 'numeric', 'real', 'smallint', 'smallmoney', 'tinyint') then 'number' \n" + + " when lower(c.DATA_TYPE) in ('char','varchar','xml','nchar','nvarchar', 'uniqueidentifier') then 'string'\n" + + " when lower(c.DATA_TYPE) in ('bit') then 'boolean'\n" + + " when lower(c.DATA_TYPE) in ('datetime', 'smalldatetime', 'time') then 'date'\n" + + " when lower(c.DATA_TYPE) in ('text','ntext') then 'text'\n" + + " when lower(c.DATA_TYPE) in ('timestamp', 'binary', 'varbinary', 'geometry', 'geography') then 'binary'\n" + + " else 'native'\n" + + " end dbgitType,\n" + + " CASE WHEN 1 IN ( \n" + + " SELECT OBJECTPROPERTY(OBJECT_ID(CONSTRAINT_SCHEMA + '.' + QUOTENAME(CONSTRAINT_NAME)),'IsPrimaryKey')\n" + + " FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE\n" + + " WHERE c.COLUMN_NAME = COLUMN_NAME AND c.TABLE_NAME = TABLE_NAME\n" + + " )\n" + + " THEN 1 ELSE 0 END isPk,\n" + + " c.IS_NULLABLE as isNullable,\n" + + " c.NUMERIC_SCALE as scale,\n" + + " c.CHARACTER_MAXIMUM_LENGTH as length,\n" + + " CASE WHEN lower(c.DATA_TYPE) in ('char', 'nchar') then '1' else '0' end isFixed," + + " c.NUMERIC_PRECISION as precision\n" + + "FROM INFORMATION_SCHEMA.COLUMNS as c\n" + + "WHERE TABLE_SCHEMA = '" + schema + "' AND TABLE_NAME = '" + nameTable + "'"; + + try(Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - ResultSet rs = stmt.executeQuery(query); while(rs.next()){ - DBTableField field = DBTableFieldFromRs(rs); + final DBTableField field = DBTableFieldFromRs(rs); listField.put(field.getName(), field); } - return listField; - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); } + + return listField; } private DBTableField DBTableFieldFromRs(ResultSet rs) throws SQLException { - DBTableField field = new DBTableField(); - field.setName(rs.getString("columnName").toLowerCase()); - if (rs.getString("isPk").equals("1")) { - field.setIsPrimaryKey(true); - } - field.setTypeSQL(getFieldType(rs)); - field.setTypeUniversal(FieldType.fromString(rs.getString("dbgitType").toUpperCase())); - field.setLength(rs.getInt("length")); - field.setScale(rs.getInt("scale")); - field.setPrecision(rs.getInt("precision")); - field.setFixed(rs.getBoolean("isFixed")); - field.setOrder(rs.getInt("columnOrder")); - return field; + final boolean isPrimaryKey = rs.getString("isPk").equals("1"); + final boolean isFixed = rs.getBoolean("isFixed"); + final boolean isNullable = rs.getBoolean("isNullable"); + final String columnName = rs.getString("columnName").toLowerCase(); + //TODO make find out column comment + final String columnDesc = ""; + //TODO make find out column default value + final String columnDefault = ""; + final String typeSQL = getFieldType(rs); + final FieldType typeUniversal = FieldType.fromString(rs.getString("dbgitType").toUpperCase()); + final int length = rs.getInt("length"); + final int scale = rs.getInt("scale"); + final int precision = rs.getInt("precision"); + final int order = rs.getInt("order"); + + return new DBTableField( + columnName, columnDesc, isPrimaryKey, isNullable, + typeSQL, typeUniversal, order, columnDefault, + length, precision, scale, isFixed + ); + } - protected String getFieldType(ResultSet rs) { - try { - StringBuilder type = new StringBuilder(); - type.append(rs.getString("mssqlType")); + protected String getFieldType(ResultSet rs) throws SQLException { - Integer max_length = rs.getInt("length"); - if (!rs.wasNull()) { - type.append("("+max_length.toString()+")"); - } - if (rs.getString("isNullable").equals("NO")){ - type.append(" NOT NULL"); - } + final StringBuilder type = new StringBuilder(); + final Integer max_length = rs.getInt("length"); + final String mssqlType = rs.getString("mssqlType"); + final boolean isNotNull = rs.getString("isNullable").equals("NO"); - return type.toString(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + type.append(mssqlType); + if (!rs.wasNull()) { + type.append("("+max_length.toString()+")"); + } + if (isNotNull){ + type.append(" NOT NULL"); } + + return type.toString(); + } public Map getIndexesWithPks(String schema, String nameTable) { - Map indexes = new HashMap<>(); - try (Statement stmt = getConnection().createStatement()){ - String query = - " SELECT DB_NAME() AS databaseName,\n" + - " sc.name as schemaName, \n" + - " t.name AS tableName,\n" + - " col.name as columnName,\n" + - " si.name AS indexName,\n" + - " si.is_primary_key isPk," + - " si.index_id as indexId,\n" + - " si.type_desc as typeName, \n" + - " CASE si.index_id WHEN 0 THEN NULL\n" + - " ELSE \n" + - " CASE is_primary_key WHEN 1 THEN\n" + - " N'ALTER TABLE ' + QUOTENAME(sc.name) + N'.' + QUOTENAME(t.name) + N' ADD CONSTRAINT ' + QUOTENAME(si.name) + N' PRIMARY KEY ' +\n" + - " CASE WHEN si.index_id > 1 THEN N'NON' ELSE N'' END + N'CLUSTERED '\n" + - " ELSE N'CREATE ' + \n" + - " CASE WHEN si.is_unique = 1 then N'UNIQUE ' ELSE N'' END +\n" + - " CASE WHEN si.index_id > 1 THEN N'NON' ELSE N'' END + N'CLUSTERED ' +\n" + - " N'INDEX ' + QUOTENAME(si.name) + N' ON ' + QUOTENAME(sc.name) + N'.' + QUOTENAME(t.name) + N' '\n" + - " END +\n" + - " /* key def */ N'(' + key_definition + N')' +\n" + - " /* includes */ CASE WHEN include_definition IS NOT NULL THEN \n" + - " N' INCLUDE (' + include_definition + N')'\n" + - " ELSE N''\n" + - " END +\n" + - " /* filters */ CASE WHEN filter_definition IS NOT NULL THEN \n" + - " N' WHERE ' + filter_definition ELSE N''\n" + - " END +\n" + - " /* with clause - compression goes here */\n" + - " CASE WHEN row_compression_partition_list IS NOT NULL OR page_compression_partition_list IS NOT NULL \n" + - " THEN N' WITH (' +\n" + - " CASE WHEN row_compression_partition_list IS NOT NULL THEN\n" + - " N'DATA_COMPRESSION = ROW ' + CASE WHEN psc.name IS NULL THEN N'' ELSE + N' ON PARTITIONS (' + row_compression_partition_list + N')' END\n" + - " ELSE N'' END +\n" + - " CASE WHEN row_compression_partition_list IS NOT NULL AND page_compression_partition_list IS NOT NULL THEN N', ' ELSE N'' END +\n" + - " CASE WHEN page_compression_partition_list IS NOT NULL THEN\n" + - " N'DATA_COMPRESSION = PAGE ' + CASE WHEN psc.name IS NULL THEN N'' ELSE + N' ON PARTITIONS (' + page_compression_partition_list + N')' END\n" + - " ELSE N'' END\n" + - " + N')'\n" + - " ELSE N''\n" + - " END +\n" + - " ' ON ' + CASE WHEN psc.name is null \n" + - " THEN ISNULL(QUOTENAME(fg.name),N'')\n" + - " ELSE psc.name + N' (' + partitioning_column.column_name + N')' \n" + - " END\n" + - " + N';'\n" + - " END AS ddl,\n" + - " si.has_filter,\n" + - " si.is_unique,\n" + - " ISNULL(pf.name, NULL) AS partition_function,\n" + - " ISNULL(psc.name, fg.name) AS partition_scheme_or_filegroup\n" + - "FROM sys.indexes AS si \n" + - "JOIN sys.index_columns ic ON si.object_id = ic.object_id and si.index_id = ic.index_id \n" + - "JOIN sys.columns col ON ic.object_id = col.object_id and ic.column_id = col.column_id \n" + - "JOIN sys.tables AS t ON si.object_id=t.object_id\n" + - "JOIN sys.schemas AS sc ON t.schema_id=sc.schema_id\n" + - "LEFT JOIN sys.dm_db_index_usage_stats AS stat ON \n" + - " stat.database_id = DB_ID() \n" + - " and si.object_id=stat.object_id \n" + - " and si.index_id=stat.index_id\n" + - "LEFT JOIN sys.partition_schemes AS psc ON si.data_space_id=psc.data_space_id\n" + - "LEFT JOIN sys.partition_functions AS pf ON psc.function_id=pf.function_id\n" + - "LEFT JOIN sys.filegroups AS fg ON si.data_space_id=fg.data_space_id\n" + - "OUTER APPLY ( SELECT STUFF (\n" + - " (SELECT N', ' + QUOTENAME(c.name) +\n" + - " CASE ic.is_descending_key WHEN 1 then N' DESC' ELSE N'' END\n" + - " FROM sys.index_columns AS ic \n" + - " JOIN sys.columns AS c ON \n" + - " ic.column_id=c.column_id \n" + - " and ic.object_id=c.object_id\n" + - " WHERE ic.object_id = si.object_id\n" + - " and ic.index_id=si.index_id\n" + - " and ic.key_ordinal > 0\n" + - " ORDER BY ic.key_ordinal FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'),1,2,'')) AS keys ( key_definition )\n" + - "OUTER APPLY (\n" + - " SELECT MAX(QUOTENAME(c.name)) AS column_name\n" + - " FROM sys.index_columns AS ic \n" + - " JOIN sys.columns AS c ON \n" + - " ic.column_id=c.column_id \n" + - " and ic.object_id=c.object_id\n" + - " WHERE ic.object_id = si.object_id\n" + - " and ic.index_id=si.index_id\n" + - " and ic.partition_ordinal = 1) AS partitioning_column\n" + - "OUTER APPLY ( SELECT STUFF (\n" + - " (SELECT N', ' + QUOTENAME(c.name)\n" + - " FROM sys.index_columns AS ic \n" + - " JOIN sys.columns AS c ON \n" + - " ic.column_id=c.column_id \n" + - " and ic.object_id=c.object_id\n" + - " WHERE ic.object_id = si.object_id\n" + - " and ic.index_id=si.index_id\n" + - " and ic.is_included_column = 1\n" + - " ORDER BY c.name FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'),1,2,'')) AS includes ( include_definition )\n" + - "OUTER APPLY ( SELECT STUFF (\n" + - " (SELECT N', ' + CAST(p.partition_number AS VARCHAR(32))\n" + - " FROM sys.partitions AS p\n" + - " WHERE p.object_id = si.object_id\n" + - " and p.index_id=si.index_id\n" + - " and p.data_compression = 1\n" + - " ORDER BY p.partition_number FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'),1,2,'')) AS row_compression_clause ( row_compression_partition_list )\n" + - "OUTER APPLY ( SELECT STUFF (\n" + - " (SELECT N', ' + CAST(p.partition_number AS VARCHAR(32))\n" + - " FROM sys.partitions AS p\n" + - " WHERE p.object_id = si.object_id\n" + - " and p.index_id=si.index_id\n" + - " and p.data_compression = 2\n" + - " ORDER BY p.partition_number FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'),1,2,'')) AS page_compression_clause ( page_compression_partition_list )\n" + - "WHERE si.type IN (1,2) /* clustered, nonclustered */\n" + + final Map indexes = new HashMap<>(); + final String query = + " SELECT DB_NAME() AS databaseName,\n" + + " sc.name as schemaName, \n" + + " t.name AS tableName,\n" + + " col.name as columnName,\n" + + " si.name AS indexName,\n" + + " si.is_primary_key isPk," + + " si.index_id as indexId,\n" + + " si.type_desc as typeName, \n" + + " CASE si.index_id WHEN 0 THEN NULL\n" + + " ELSE \n" + + " CASE is_primary_key WHEN 1 THEN\n" + + " N'ALTER TABLE ' + QUOTENAME(sc.name) + N'.' + QUOTENAME(t.name) + N' ADD CONSTRAINT ' + QUOTENAME(si.name) + N' PRIMARY KEY ' +\n" + + " CASE WHEN si.index_id > 1 THEN N'NON' ELSE N'' END + N'CLUSTERED '\n" + + " ELSE N'CREATE ' + \n" + + " CASE WHEN si.is_unique = 1 then N'UNIQUE ' ELSE N'' END +\n" + + " CASE WHEN si.index_id > 1 THEN N'NON' ELSE N'' END + N'CLUSTERED ' +\n" + + " N'INDEX ' + QUOTENAME(si.name) + N' ON ' + QUOTENAME(sc.name) + N'.' + QUOTENAME(t.name) + N' '\n" + + " END +\n" + + " /* key def */ N'(' + key_definition + N')' +\n" + + " /* includes */ CASE WHEN include_definition IS NOT NULL THEN \n" + + " N' INCLUDE (' + include_definition + N')'\n" + + " ELSE N''\n" + + " END +\n" + + " /* filters */ CASE WHEN filter_definition IS NOT NULL THEN \n" + + " N' WHERE ' + filter_definition ELSE N''\n" + + " END +\n" + + " /* with clause - compression goes here */\n" + + " CASE WHEN row_compression_partition_list IS NOT NULL OR page_compression_partition_list IS NOT NULL \n" + + " THEN N' WITH (' +\n" + + " CASE WHEN row_compression_partition_list IS NOT NULL THEN\n" + + " N'DATA_COMPRESSION = ROW ' + CASE WHEN psc.name IS NULL THEN N'' ELSE + N' ON PARTITIONS (' + row_compression_partition_list + N')' END\n" + + " ELSE N'' END +\n" + + " CASE WHEN row_compression_partition_list IS NOT NULL AND page_compression_partition_list IS NOT NULL THEN N', ' ELSE N'' END +\n" + + " CASE WHEN page_compression_partition_list IS NOT NULL THEN\n" + + " N'DATA_COMPRESSION = PAGE ' + CASE WHEN psc.name IS NULL THEN N'' ELSE + N' ON PARTITIONS (' + page_compression_partition_list + N')' END\n" + + " ELSE N'' END\n" + + " + N')'\n" + + " ELSE N''\n" + + " END +\n" + + " ' ON ' + CASE WHEN psc.name is null \n" + + " THEN ISNULL(QUOTENAME(fg.name),N'')\n" + + " ELSE psc.name + N' (' + partitioning_column.column_name + N')' \n" + + " END\n" + + " + N';'\n" + + " END AS ddl,\n" + + " si.has_filter,\n" + + " si.is_unique,\n" + + " ISNULL(pf.name, NULL) AS partition_function,\n" + + " ISNULL(psc.name, fg.name) AS partition_scheme_or_filegroup\n" + + "FROM sys.indexes AS si \n" + + "JOIN sys.index_columns ic ON si.object_id = ic.object_id and si.index_id = ic.index_id \n" + + "JOIN sys.columns col ON ic.object_id = col.object_id and ic.column_id = col.column_id \n" + + "JOIN sys.tables AS t ON si.object_id=t.object_id\n" + + "JOIN sys.schemas AS sc ON t.schema_id=sc.schema_id\n" + + "LEFT JOIN sys.dm_db_index_usage_stats AS stat ON \n" + + " stat.database_id = DB_ID() \n" + + " and si.object_id=stat.object_id \n" + + " and si.index_id=stat.index_id\n" + + "LEFT JOIN sys.partition_schemes AS psc ON si.data_space_id=psc.data_space_id\n" + + "LEFT JOIN sys.partition_functions AS pf ON psc.function_id=pf.function_id\n" + + "LEFT JOIN sys.filegroups AS fg ON si.data_space_id=fg.data_space_id\n" + + "OUTER APPLY ( SELECT STUFF (\n" + + " (SELECT N', ' + QUOTENAME(c.name) +\n" + + " CASE ic.is_descending_key WHEN 1 then N' DESC' ELSE N'' END\n" + + " FROM sys.index_columns AS ic \n" + + " JOIN sys.columns AS c ON \n" + + " ic.column_id=c.column_id \n" + + " and ic.object_id=c.object_id\n" + + " WHERE ic.object_id = si.object_id\n" + + " and ic.index_id=si.index_id\n" + + " and ic.key_ordinal > 0\n" + + " ORDER BY ic.key_ordinal FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'),1,2,'')) AS keys ( key_definition )\n" + + "OUTER APPLY (\n" + + " SELECT MAX(QUOTENAME(c.name)) AS column_name\n" + + " FROM sys.index_columns AS ic \n" + + " JOIN sys.columns AS c ON \n" + + " ic.column_id=c.column_id \n" + + " and ic.object_id=c.object_id\n" + + " WHERE ic.object_id = si.object_id\n" + + " and ic.index_id=si.index_id\n" + + " and ic.partition_ordinal = 1) AS partitioning_column\n" + + "OUTER APPLY ( SELECT STUFF (\n" + + " (SELECT N', ' + QUOTENAME(c.name)\n" + + " FROM sys.index_columns AS ic \n" + + " JOIN sys.columns AS c ON \n" + + " ic.column_id=c.column_id \n" + + " and ic.object_id=c.object_id\n" + + " WHERE ic.object_id = si.object_id\n" + + " and ic.index_id=si.index_id\n" + + " and ic.is_included_column = 1\n" + + " ORDER BY c.name FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'),1,2,'')) AS includes ( include_definition )\n" + + "OUTER APPLY ( SELECT STUFF (\n" + + " (SELECT N', ' + CAST(p.partition_number AS VARCHAR(32))\n" + + " FROM sys.partitions AS p\n" + + " WHERE p.object_id = si.object_id\n" + + " and p.index_id=si.index_id\n" + + " and p.data_compression = 1\n" + + " ORDER BY p.partition_number FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'),1,2,'')) AS row_compression_clause ( row_compression_partition_list )\n" + + "OUTER APPLY ( SELECT STUFF (\n" + + " (SELECT N', ' + CAST(p.partition_number AS VARCHAR(32))\n" + + " FROM sys.partitions AS p\n" + + " WHERE p.object_id = si.object_id\n" + + " and p.index_id=si.index_id\n" + + " and p.data_compression = 2\n" + + " ORDER BY p.partition_number FOR XML PATH(''), TYPE).value('.', 'NVARCHAR(MAX)'),1,2,'')) AS page_compression_clause ( page_compression_partition_list )\n" + + "WHERE si.type IN (1,2) /* clustered, nonclustered */\n" + // "AND si.is_primary_key = 0 /* no PKs */\n" + - "AND si.is_hypothetical = 0 /* bugged feature, always better to delete, no need to store and reconstruct them */\n" + - "AND upper(t.name) = upper('" + nameTable + "') AND upper(sc.name) = upper('" + schema + "')" + - "OPTION (RECOMPILE);"; + "AND si.is_hypothetical = 0 /* bugged feature, always better to delete, no need to store and reconstruct them */\n" + + "AND upper(t.name) = upper('" + nameTable + "') AND upper(sc.name) = upper('" + schema + "')" + + "OPTION (RECOMPILE);"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ - ResultSet rs = stmt.executeQuery(query); while(rs.next()){ - String name = rs.getString("indexName"); - String owner = rs.getString("owner"); - DBIndex index = new DBIndex(name, schema, owner); + final String name = rs.getString("indexName"); + final String owner = rs.getString("owner"); + final String sql = rs.getString("ddl"); + final DBIndex index = new DBIndex(name, new StringProperties(rs), schema, owner, Collections.emptySet(), sql); - rowToProperties(rs, index.getOptions()); indexes.put(index.getName(), index); - - } return indexes; - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "indexes").toString()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "indexes").toString(), e); + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "indexes").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public Map getIndexes(String schema, String nameTable){ - Map indexes = getIndexesWithPks(schema, nameTable); + final Map indexes = getIndexesWithPks(schema, nameTable); + indexes.values().removeIf(x->x.getOptions().getChildren().get("ispk").getData().equals("1")); return indexes; } @Override public Map getConstraints(String schema, String nameTable) { - Map constraints = new HashMap<>(); - ArrayList queries = new ArrayList<>(); + final Map constraints = new HashMap<>(); + final ArrayList queries = new ArrayList<>(); //TODO [] in object names //check - queries.add("SELECT sc.name as schemaName, t.name as tableName, col.name as columnName, c.name as constraintName, c.name as indexName, c.type_desc as constraintType, \n" + - "'ALTER TABLE ' + sc.name + '.' + t.name + ' ADD CONSTRAINT ' + c.name + ' CHECK ' + c.definition + ';' as ddl\n" + - "FROM sys.check_constraints c\n" + - "JOIN sys.tables t ON c.parent_object_id = t.object_id \n" + - "LEFT OUTER JOIN sys.columns col on col.column_id = c.parent_column_id AND col.object_id = c.parent_object_id\n" + - "JOIN sys.schemas AS sc ON t.schema_id=sc.schema_id \n" + - "WHERE t.name = ? AND sc.name = ?"); + queries.add( + "SELECT sc.name as schemaName, t.name as tableName, col.name as columnName, c.name as constraintName, c.name as indexName, c.type_desc as constraintType, \n" + + "'ALTER TABLE ' + sc.name + '.' + t.name + ' ADD CONSTRAINT ' + c.name + ' CHECK ' + c.definition + ';' as ddl\n" + + "FROM sys.check_constraints c\n" + + "JOIN sys.tables t ON c.parent_object_id = t.object_id \n" + + "LEFT OUTER JOIN sys.columns col on col.column_id = c.parent_column_id AND col.object_id = c.parent_object_id\n" + + "JOIN sys.schemas AS sc ON t.schema_id=sc.schema_id \n" + + "WHERE t.name = :name AND sc.name = :schema"); //default - queries.add("SELECT sc.name AS schemaName, t.name AS tableName, col.name AS columnName, c.name AS constraintName, c.type_desc AS constraintType, \n" + - "'ALTER TABLE ' + sc.name + '.' + t.name + ' ADD CONSTRAINT ' + c.name+ ' DEFAULT ' \n" + - " + CASE WHEN ISNUMERIC(ic.COLUMN_DEFAULT) = 1 \n" + - " THEN TRY_CONVERT(nvarchar, TRY_CONVERT(numeric, ic.COLUMN_DEFAULT))\n" + - " ELSE '' + ic.COLUMN_DEFAULT + '' END\n" + - " + ' FOR [' + col.name + '];' AS ddl\n" + - "FROM sys.default_constraints c\n" + - "JOIN sys.tables t ON c.parent_object_id = t.object_id \n" + - "JOIN sys.columns col ON col.default_object_id = c.object_id\n" + - "JOIN sys.schemas AS sc ON t.schema_id=sc.schema_id \n" + - "JOIN INFORMATION_SCHEMA.COLUMNS ic on t.name = ic.TABLE_NAME AND col.name = ic.COLUMN_NAME \n" + - "WHERE t.name = ? AND sc.name = ?\n"); + queries.add( + "SELECT sc.name AS schemaName, t.name AS tableName, col.name AS columnName, c.name AS constraintName, c.type_desc AS constraintType, \n" + + "'ALTER TABLE ' + sc.name + '.' + t.name + ' ADD CONSTRAINT ' + c.name+ ' DEFAULT ' \n" + + " + CASE WHEN ISNUMERIC(ic.COLUMN_DEFAULT) = 1 \n" + + " THEN TRY_CONVERT(nvarchar, TRY_CONVERT(numeric, ic.COLUMN_DEFAULT))\n" + + " ELSE '' + ic.COLUMN_DEFAULT + '' END\n" + + " + ' FOR [' + col.name + '];' AS ddl\n" + + "FROM sys.default_constraints c\n" + + "JOIN sys.tables t ON c.parent_object_id = t.object_id \n" + + "JOIN sys.columns col ON col.default_object_id = c.object_id\n" + + "JOIN sys.schemas AS sc ON t.schema_id=sc.schema_id \n" + + "JOIN INFORMATION_SCHEMA.COLUMNS ic on t.name = ic.TABLE_NAME AND col.name = ic.COLUMN_NAME \n" + + "WHERE t.name = :name AND sc.name = :schema\n" + ); //unique - queries.add("SELECT TC.TABLE_SCHEMA AS schemaName, TC.TABLE_NAME AS tableName, CC.Column_Name AS columnName, TC.Constraint_Name AS constraintName, TC.CONSTRAINT_TYPE AS constraintType,\n" + - "'ALTER TABLE ' + TC.TABLE_SCHEMA + '.' + TC.TABLE_NAME + ' ADD CONSTRAINT ' + TC.CONSTRAINT_NAME + ' UNIQUE NONCLUSTERED ([' + CC.COLUMN_NAME + ']);' AS ddl\n" + - "FROM INFORMATION_SCHEMA.table_constraints TC\n" + - "INNER JOIN INFORMATION_SCHEMA.constraint_column_usage CC on TC.Constraint_Name = CC.Constraint_Name\n" + - "WHERE TC.constraint_type = 'Unique' AND TC.TABLE_NAME = ? AND TC.TABLE_SCHEMA = ? ---- PARAMETER 1,2\n"); + queries.add( + "SELECT TC.TABLE_SCHEMA AS schemaName, TC.TABLE_NAME AS tableName, CC.Column_Name AS columnName, TC.Constraint_Name AS constraintName, TC.CONSTRAINT_TYPE AS constraintType,\n" + + "'ALTER TABLE ' + TC.TABLE_SCHEMA + '.' + TC.TABLE_NAME + ' ADD CONSTRAINT ' + TC.CONSTRAINT_NAME + ' UNIQUE NONCLUSTERED ([' + CC.COLUMN_NAME + ']);' AS ddl\n" + + "FROM INFORMATION_SCHEMA.table_constraints TC\n" + + "INNER JOIN INFORMATION_SCHEMA.constraint_column_usage CC on TC.Constraint_Name = CC.Constraint_Name\n" + + "WHERE TC.constraint_type = 'Unique' AND TC.TABLE_NAME = :name AND TC.TABLE_SCHEMA = :schema ---- PARAMETER 1,2\n" + ); //foreign - queries.add("SELECT ss.name as schemaName, t.name as tableName, sc.name as columnName, o.name as constraintName, o.type_desc as constraintType, refss.name as refSchemaName, refst.name as refTableName, refsc.name as refColumnName, " + - "'ALTER TABLE ' + ss.name + '.' + t.name + ' ADD CONSTRAINT ' + o.name + ' FOREIGN KEY ('+ sc.name + ') references ' + refss.name + '.' + refst.name + '(' + refsc.name + ');' as ddl\n" + - "FROM sys.foreign_key_columns c\n" + - "JOIN sys.objects o ON c.constraint_object_id = o.object_id\n" + - "LEFT OUTER JOIN sys.tables t on t.object_id = c.parent_object_id \n" + - "LEFT OUTER JOIN sys.schemas ss on ss.schema_id = o.schema_id \n" + - "LEFT OUTER JOIN sys.columns sc on sc.object_id = c.parent_object_id AND sc.column_id = c.parent_column_id\n" + - "LEFT OUTER JOIN sys.tables refst on refst.object_id = c.referenced_object_id\n" + - "LEFT OUTER JOIN sys.schemas refss on refss.schema_id = refst.schema_id\n" + - "LEFT OUTER JOIN sys.columns refsc on refsc.object_id = c.referenced_object_id AND refsc.column_id = c.referenced_column_id \n" + - "WHERE t.name = ? AND ss.name = ?\n" + queries.add( + "SELECT ss.name as schemaName, t.name as tableName, sc.name as columnName, o.name as constraintName, o.type_desc as constraintType, refss.name as refSchemaName, refst.name as refTableName, refsc.name as refColumnName, " + + "'ALTER TABLE ' + ss.name + '.' + t.name + ' ADD CONSTRAINT ' + o.name + ' FOREIGN KEY ('+ sc.name + ') references ' + refss.name + '.' + refst.name + '(' + refsc.name + ');' as ddl\n" + + "FROM sys.foreign_key_columns c\n" + + "JOIN sys.objects o ON c.constraint_object_id = o.object_id\n" + + "LEFT OUTER JOIN sys.tables t on t.object_id = c.parent_object_id \n" + + "LEFT OUTER JOIN sys.schemas ss on ss.schema_id = o.schema_id \n" + + "LEFT OUTER JOIN sys.columns sc on sc.object_id = c.parent_object_id AND sc.column_id = c.parent_column_id\n" + + "LEFT OUTER JOIN sys.tables refst on refst.object_id = c.referenced_object_id\n" + + "LEFT OUTER JOIN sys.schemas refss on refss.schema_id = refst.schema_id\n" + + "LEFT OUTER JOIN sys.columns refsc on refsc.object_id = c.referenced_object_id AND refsc.column_id = c.referenced_column_id \n" + + "WHERE t.name = :name AND ss.name = :schema\n" ); + final Iterator it = queries.iterator(); + while (it.hasNext()) { + final String query = it.next(); + try ( + PreparedStatement stmt = preparedStatement(getConnection(), query, ImmutableMap.of("name", nameTable, "schema" , schema)); + ResultSet rs = stmt.executeQuery(query); + ){ - Iterator it = queries.iterator(); - try { - while (it.hasNext()) { - String query = it.next(); - PreparedStatement stmt = connect.prepareStatement(query); - stmt.setString(2, schema); - stmt.setString(1, nameTable); - ResultSet rs = stmt.executeQuery(); - - - while (rs.next()) { - String name = rs.getString("constraintName"); - String type = rs.getString("constraintType"); - String owner = "postgres"; - - DBConstraint con = new DBConstraint(name, schema, owner, type); - rowToProperties(rs, con.getOptions()); - constraints.put(con.getName(), con); - } - stmt.close(); - } + while (rs.next()) { + final String name = rs.getString("constraintName"); + final String type = rs.getString("constraintType"); + final String sql = rs.getString("ddl"); + final String owner = schema; - //primary keys - Map indexes = getIndexesWithPks(schema, nameTable); - indexes.values().removeIf(x->x.getOptions().getChildren().get("ispk").getData().equals("0")); - for(DBIndex pki:indexes.values()){ - String constraintType = pki.getOptions().getChildren().get("typename").getData(); - DBConstraint pkc = new DBConstraint(pki.getName(),pki.getSchema(),pki.getOwner(), constraintType); - pkc.setOptions(pki.getOptions()); - constraints.put(pkc.getName(), pkc); + final DBConstraint con = new DBConstraint(name, new StringProperties(rs), schema, owner, Collections.emptySet(), sql, type); + constraints.put(con.getName(), con); + } + } catch (Exception ex){ + final String msg = lang.getValue("errors", "adapter", "constraints").toString(); + throw new ExceptionDBGitRunTime(msg, ex); } + } + + //primary keys + final Map indexes = getIndexesWithPks(schema, nameTable); + indexes.values().removeIf(x->x.getOptions().getChildren().get("ispk").getData().equals("0")); + + for( DBIndex pki : indexes.values() ){ + final String constraintType = pki.getOptions().getChildren().get("typename").getData(); + final DBConstraint pkc = new DBConstraint( + pki.getName(), + pki.getOptions(), + pki.getSchema(), + pki.getOwner(), + new HashSet<>(pki.getDependencies()), + pki.getSql(), + constraintType + ); + pkc.setOptions(pki.getOptions()); + constraints.put(pkc.getName(), pkc); + } - return constraints; + return constraints; - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "constraints").toString()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "constraints").toString(), e); - } } @Override public Map getViews(String schema) { - Map listView = new HashMap(); - try (Statement stmt = getConnection().createStatement()){ - String query = - "SELECT \n" + - " sp.name as ownerName, sp.type_desc as ownerType, ss.name AS schemaName, sv.name AS viewName, sm.definition as ddl, \n" + - " sv.type_desc as typeName, sm.uses_ansi_nulls, sm.uses_quoted_identifier, sm.is_schema_bound, \n" + - " OBJECTPROPERTYEX(sv.object_id,'IsIndexable') AS IsIndexable,\n" + - " OBJECTPROPERTYEX(sv.object_id,'IsIndexed') AS IsIndexed\n" + - "FROM sys.views sv\n" + - "JOIN sys.schemas ss ON sv.schema_id = ss.schema_id\n" + - "LEFT OUTER JOIN sys.sql_modules sm on sv.object_id = sm.object_id\n" + - "LEFT OUTER JOIN sys.database_principals sp on sv.principal_id = sp.principal_id"; - - ResultSet rs = stmt.executeQuery(query); + final Map listView = new HashMap(); + final String query = + "SELECT \n" + + " sp.name as ownerName, sp.type_desc as ownerType, ss.name AS schemaName, sv.name AS viewName, sm.definition as ddl, \n" + + " sv.type_desc as typeName, sm.uses_ansi_nulls, sm.uses_quoted_identifier, sm.is_schema_bound, \n" + + " OBJECTPROPERTYEX(sv.object_id,'IsIndexable') AS IsIndexable,\n" + + " OBJECTPROPERTYEX(sv.object_id,'IsIndexed') AS IsIndexed\n" + + "FROM sys.views sv\n" + + "JOIN sys.schemas ss ON sv.schema_id = ss.schema_id\n" + + "LEFT OUTER JOIN sys.sql_modules sm on sv.object_id = sm.object_id\n" + + "LEFT OUTER JOIN sys.database_principals sp on sv.principal_id = sp.principal_id"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + while(rs.next()){ - String name = rs.getString("viewName"); - String schemaName = rs.getString("schemaName"); - String owner = rs.getString("ownerName"); - DBView view = new DBView(name, schema, owner); - rowToProperties(rs, view.getOptions()); + final String name = rs.getString("viewName"); + final String schemaName = rs.getString("schemaName"); + final String owner = rs.getString("ownerName"); + final String sql = rs.getString("ddl"); + + final DBView view = new DBView(name, new StringProperties(rs), schema, owner, Collections.emptySet(), sql); listView.put(name, view); } return listView; - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views") + ": " + e.getMessage()); + + } catch(Exception e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "views"); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public DBView getView(String schema, String name) { + //TODO single-version query with ExceptionDBGitNotFound try { return getViews(schema).get(name); - - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "views").toString() + ": "+ e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views").toString() + ": "+ e.getMessage()); + } catch(Exception e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "views"); + throw new ExceptionDBGitRunTime(msg, e); } } @@ -667,119 +684,124 @@ public Map getPackages(String schema) { @Override public DBPackage getPackage(String schema, String name) { // No such implementation in MSSQL - return null; + throw new ExceptionDBGitRunTime(new ExceptionDBGitObjectNotFound("cannot get packages on mssql")); } @Override public Map getProcedures(String schema) { - Map listProcedure = new HashMap(); - try (Statement stmt = getConnection().createStatement()){ - String query = - "SELECT s.name schemaName, o.name procedureName, o.type_desc as typeName, definition ddl, USER_NAME(so.uid) AS owner \n" + - "FROM sys.sql_modules m\n" + - "JOIN sys.procedures p ON m.object_id = p.object_id\n" + - "JOIN sys.objects o \n" + - " ON o.object_id = p.object_id \n" + - " AND Left(o.name, 3) NOT IN ('sp_', 'xp_', 'ms_') \n" + - "JOIN sys.schemas s ON s.schema_id = o.schema_id\n" + - "JOIN sysobjects so on o.object_id = so.id\n" + - "WHERE s.name = '" + schema + "'\n"; - - ResultSet rs = stmt.executeQuery(query); + final Map listProcedure = new HashMap(); + final String query = + "SELECT s.name schemaName, o.name procedureName, o.type_desc as typeName, definition ddl, USER_NAME(so.uid) AS owner \n" + + "FROM sys.sql_modules m\n" + + "JOIN sys.procedures p ON m.object_id = p.object_id\n" + + "JOIN sys.objects o \n" + + " ON o.object_id = p.object_id \n" + + " AND Left(o.name, 3) NOT IN ('sp_', 'xp_', 'ms_') \n" + + "JOIN sys.schemas s ON s.schema_id = o.schema_id\n" + + "JOIN sysobjects so on o.object_id = so.id\n" + + "WHERE s.name = '" + schema + "'\n"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ while(rs.next()){ - String name = rs.getString("procedureName"); - String owner = rs.getString("owner"); - DBProcedure proc = new DBProcedure(name, schema, owner); - rowToProperties(rs,proc.getOptions()); + final String name = rs.getString("procedureName"); + final String owner = rs.getString("owner"); + final String sql = rs.getString("ddl"); + final StringProperties options = new StringProperties(rs); + final DBProcedure proc = new DBProcedure(name, options, schema, owner, Collections.emptySet(), sql); listProcedure.put(name, proc); } }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); + final String msg = lang.getValue("errors", "adapter", "prc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listProcedure; } @Override public DBProcedure getProcedure(String schema, String name) { - try (Statement stmt = getConnection().createStatement()){ - String query = - "SELECT s.name schemaName, o.name procedureName, o.type_desc as typeName, definition ddl, USER_NAME(so.uid) AS owner \n" + - "FROM sys.sql_modules m\n" + - "JOIN sys.procedures p ON m.object_id = p.object_id\n" + - "JOIN sys.objects o \n" + - " ON o.object_id = p.object_id \n" + - " AND Left(o.name, 3) NOT IN ('sp_', 'xp_', 'ms_') -- filter out system ones\n" + - "JOIN sys.schemas s ON s.schema_id = o.schema_id\n" + - "JOIN sysobjects so on o.object_id = so.id \n" + - "WHERE s.name = '" + schema + "' AND o.name = '" + name + "'"; - ResultSet rs = stmt.executeQuery(query); - DBProcedure proc = null; - - while (rs.next()) { - String owner = rs.getString("owner"); - String procedureName = rs.getString("procedureName"); - proc = new DBProcedure(procedureName, schema, owner); - rowToProperties(rs,proc.getOptions()); - } - stmt.close(); - - return proc; - - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); + final String query = + "SELECT s.name schemaName, o.name procedureName, o.type_desc as typeName, definition ddl, USER_NAME(so.uid) AS owner \n" + + "FROM sys.sql_modules m\n" + + "JOIN sys.procedures p ON m.object_id = p.object_id\n" + + "JOIN sys.objects o \n" + + " ON o.object_id = p.object_id \n" + + " AND Left(o.name, 3) NOT IN ('sp_', 'xp_', 'ms_') -- filter out system ones\n" + + "JOIN sys.schemas s ON s.schema_id = o.schema_id\n" + + "JOIN sysobjects so on o.object_id = so.id \n" + + "WHERE s.name = '" + schema + "' AND o.name = '" + name + "'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + + if (!rs.next()) throw new ExceptionDBGitObjectNotFound(""); + + final String owner = rs.getString("owner"); + final String procedureName = rs.getString("procedureName"); + final String sql = rs.getString("ddl"); + final StringProperties options = new StringProperties(rs); + + return new DBProcedure(procedureName, options, schema, owner, Collections.emptySet(), sql); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "prc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public Map getFunctions(String schema) { - Map listFunction = new HashMap<>(); - try (Statement stmt = getConnection().createStatement()){ - String query = - "SELECT ss.name schemaName, o.name functionName, type_desc typeName, definition ddl, USER_NAME(so.uid) owner \n" + - "FROM sys.sql_modules m \n" + - "INNER JOIN sys.objects o ON m.object_id = o.object_id\n" + - "INNER JOIN sysobjects so ON m.object_id = so.id\n" + - "INNER JOIN sys.schemas ss ON ss.schema_id = o.schema_id\n" + - "WHERE type_desc like '%function%' AND ss.name = '" + schema + "'\n"; + final Map listFunction = new HashMap<>(); + final String query = + "SELECT ss.name schemaName, o.name functionName, type_desc typeName, definition ddl, USER_NAME(so.uid) owner \n" + + "FROM sys.sql_modules m \n" + + "INNER JOIN sys.objects o ON m.object_id = o.object_id\n" + + "INNER JOIN sysobjects so ON m.object_id = so.id\n" + + "INNER JOIN sys.schemas ss ON ss.schema_id = o.schema_id\n" + + "WHERE type_desc like '%function%' AND ss.name = '" + schema + "'\n"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ - ResultSet rs = stmt.executeQuery(query); while(rs.next()){ - String name = rs.getString("functionName"); - String owner = rs.getString("owner"); - DBFunction func = new DBFunction(name, schema, owner); - rowToProperties(rs,func.getOptions()); + final String name = rs.getString("functionName"); + final String owner = rs.getString("owner"); + final String sql = rs.getString("ddl"); + final StringProperties options = new StringProperties(rs); + + final DBFunction func = new DBFunction(name, options, schema, owner, Collections.emptySet(), sql); listFunction.put(name, func); } - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "fnc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listFunction; } @Override public DBFunction getFunction(String schema, String name) { - try (Statement stmt = getConnection().createStatement()){ - String query = - "SELECT ss.name schemaName, o.name functionName, type_desc typeName, definition ddl, USER_NAME(so.uid) owner \n" + - "FROM sys.sql_modules m \n" + - "INNER JOIN sys.objects o ON m.object_id = o.object_id\n" + - "INNER JOIN sysobjects so ON m.object_id = so.id\n" + - "INNER JOIN sys.schemas ss ON ss.schema_id = o.schema_id\n" + - "WHERE type_desc like '%function%' AND ss.name = '" + schema + "' AND o.name = '" + name + "'\n"; - - DBFunction func = null; - ResultSet rs = stmt.executeQuery(query); - while (rs.next()) { - String functionName = rs.getString("functionName"); - String owner = rs.getString("owner"); - func = new DBFunction(functionName, schema, owner); - rowToProperties(rs,func.getOptions()); - } - return func; + final String query = + "SELECT ss.name schemaName, o.name functionName, type_desc typeName, definition ddl, USER_NAME(so.uid) owner \n" + + "FROM sys.sql_modules m \n" + + "INNER JOIN sys.objects o ON m.object_id = o.object_id\n" + + "INNER JOIN sysobjects so ON m.object_id = so.id\n" + + "INNER JOIN sys.schemas ss ON ss.schema_id = o.schema_id\n" + + "WHERE type_desc like '%function%' AND ss.name = '" + schema + "' AND o.name = '" + name + "'\n"; - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + + if (!rs.next()) throw new ExceptionDBGitObjectNotFound(""); + + final String functionName = rs.getString("functionName"); + final String owner = rs.getString("owner"); + final String sql = rs.getString("ddl"); + final StringProperties options = new StringProperties(rs); + + return new DBFunction(functionName, options, schema, owner, Collections.emptySet(), sql); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "fnc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @@ -787,134 +809,135 @@ public DBFunction getFunction(String schema, String name) { // it is not possible to get definition of an encrypted trigger public Map getTriggers(String schema) { - Map listTrigger = new HashMap(); - try (Statement stmt = getConnection().createStatement()){ - String query = - "SELECT \n" + - " s.name schemaName, \n" + - " o.name triggerName, \n" + - " USER_NAME(o.uid) owner, \n" + - " OBJECT_NAME(parent_obj) tableName, \n" + - " m.definition as ddl, \n" + - " OBJECTPROPERTY(id, 'IsEncrypted') AS encrypted \n" + - "FROM sysobjects o\n" + - "INNER JOIN sys.tables t ON o.parent_obj = t.object_id \n" + - "INNER JOIN sys.schemas s ON t.schema_id = s.schema_id \n" + - "INNER JOIN sys.sql_modules m ON m.object_id = o.id\n" + - "WHERE o.type = 'TR' AND s.name = '" + schema + "'\n"; + final Map listTrigger = new HashMap(); + final String query = + "SELECT \n" + + " s.name schemaName, \n" + + " o.name triggerName, \n" + + " USER_NAME(o.uid) owner, \n" + + " OBJECT_NAME(parent_obj) tableName, \n" + + " m.definition as ddl, \n" + + " OBJECTPROPERTY(id, 'IsEncrypted') AS encrypted \n" + + "FROM sysobjects o\n" + + "INNER JOIN sys.tables t ON o.parent_obj = t.object_id \n" + + "INNER JOIN sys.schemas s ON t.schema_id = s.schema_id \n" + + "INNER JOIN sys.sql_modules m ON m.object_id = o.id\n" + + "WHERE o.type = 'TR' AND s.name = '" + schema + "'\n"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ - ResultSet rs = stmt.executeQuery(query); while(rs.next()){ - String name = rs.getString("triggerName"); - String owner = rs.getString("owner"); - DBTrigger trigger = new DBTrigger(name, schema, owner); - trigger.setSchema(schema); - trigger.setOwner(owner); - // -- what means owner? oracle/postgres or owner like database user/schema - // -- IMO its a database object owner - - rowToProperties(rs, trigger.getOptions()); + final String name = rs.getString("triggerName"); + final String owner = rs.getString("owner"); + final String sql = rs.getString("ddl"); + final StringProperties options = new StringProperties(rs); + + DBTrigger trigger = new DBTrigger(name, options, schema, owner, Collections.emptySet(), sql); listTrigger.put(name, trigger); } return listTrigger; - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "triggers").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } public DBTrigger getTrigger(String schema, String name) { - DBTrigger trigger = null; - try (Statement stmt = getConnection().createStatement()){ - String query = - "SELECT \n" + - " s.name schemaName, \n" + - " o.name triggerName, \n" + - " USER_NAME(o.uid) owner, \n" + - " OBJECT_NAME(parent_obj) tableName, \n" + - " m.definition as ddl, \n" + - " OBJECTPROPERTY(id, 'IsEncrypted') AS encrypted \n" + - "FROM sysobjects o\n" + - "INNER JOIN sys.tables t ON o.parent_obj = t.object_id \n" + - "INNER JOIN sys.schemas s ON t.schema_id = s.schema_id \n" + - "INNER JOIN sys.sql_modules m ON m.object_id = o.id\n" + - "WHERE o.type = 'TR' AND s.name = '" + schema + "' AND o.name = '" + name + "'\n"; - - ResultSet rs = stmt.executeQuery(query); - while(rs.next()){ - String tname = rs.getString("triggerName"); - String owner = rs.getString("owner"); - trigger = new DBTrigger(tname, schema, owner); - trigger.setSchema(schema); - trigger.setOwner(owner); - rowToProperties(rs, trigger.getOptions()); - } - return trigger; - }catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); + final String query = + "SELECT \n" + + " s.name schemaName, \n" + + " o.name triggerName, \n" + + " USER_NAME(o.uid) owner, \n" + + " OBJECT_NAME(parent_obj) tableName, \n" + + " m.definition as ddl, \n" + + " OBJECTPROPERTY(id, 'IsEncrypted') AS encrypted \n" + + "FROM sysobjects o\n" + + "INNER JOIN sys.tables t ON o.parent_obj = t.object_id \n" + + "INNER JOIN sys.schemas s ON t.schema_id = s.schema_id \n" + + "INNER JOIN sys.sql_modules m ON m.object_id = o.id\n" + + "WHERE o.type = 'TR' AND s.name = '" + schema + "' AND o.name = '" + name + "'\n"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + + if(!rs.next()) throw new ExceptionDBGitObjectNotFound(""); + + final String tname = rs.getString("triggerName"); + final String owner = rs.getString("owner"); + final String sql = rs.getString("ddl"); + final StringProperties options = new StringProperties(rs); + + return new DBTrigger(name, options, schema, owner, Collections.emptySet(), sql); + + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "triggers").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public DBTableData getTableData(String schema, String nameTable) { - try { - Statement stmt = getConnection().createStatement(); - DBTableData data = new DBTableData(); + final String dataQuery = "SELECT * FROM [" + schema + "].[" + nameTable + "]"; - int maxRowsCount = DBGitConfig.getInstance().getInteger( - "core", - "MAX_ROW_COUNT_FETCH", - DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH) - ); + final int maxRowsCount = DBGitConfig.getInstance().getInteger( + "core", "MAX_ROW_COUNT_FETCH", + DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH) + ); - boolean isLimitedFetch = DBGitConfig.getInstance().getBoolean( - "core", - "LIMIT_FETCH", - DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true) - ); + final boolean isLimitedFetch = DBGitConfig.getInstance().getBoolean( + "core", "LIMIT_FETCH", + DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true) + ); - if (isLimitedFetch) - { - String query = - "SELECT COALESCE(SUM(PART.rows), 0) AS rowsCount\n" + - "FROM sys.tables TBL\n" + - "INNER JOIN sys.partitions PART ON TBL.object_id = PART.object_id\n" + - "INNER JOIN sys.indexes IDX ON PART.object_id = IDX.object_id AND PART.index_id = IDX.index_id\n" + - "INNER JOIN sys.schemas S ON S.schema_id = TBL.schema_id\n" + - "WHERE TBL.name = '"+nameTable+"' AND S.name = '"+schema+"' AND IDX.index_id < 2\n" + - "GROUP BY TBL.object_id, TBL.name"; - - ResultSet rs = stmt.executeQuery(query); - rs.next(); - if (rs.getInt("rowsCount") > maxRowsCount) { - data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); - return data; - } - } + try{ - ResultSet rs = stmt.executeQuery("SELECT * FROM [" + schema + "].[" + nameTable + "]"); - data.setResultSet(rs); - return data; + if (isLimitedFetch) { + final String rowsCountQuery = + "SELECT COALESCE(SUM(PART.rows), 0) AS rowsCount\n" + + "FROM sys.tables TBL\n" + + "INNER JOIN sys.partitions PART ON TBL.object_id = PART.object_id\n" + + "INNER JOIN sys.indexes IDX ON PART.object_id = IDX.object_id AND PART.index_id = IDX.index_id\n" + + "INNER JOIN sys.schemas S ON S.schema_id = TBL.schema_id\n" + + "WHERE TBL.name = '"+nameTable+"' AND S.name = '"+schema+"' AND IDX.index_id < 2\n" + + "GROUP BY TBL.object_id, TBL.name"; + + try( + Statement st = getConnection().createStatement(); + ResultSet rs = st.executeQuery(rowsCountQuery); + ){ + if(!rs.next()) throw new ExceptionDBGitRunTime("rows coubt resultset is empty"); + if (rs.getInt("rowsCount") > maxRowsCount) { + return new DBTableData(DBTableData.ERROR_LIMIT_ROWS); + } + } + + } + + return new DBTableData(getConnection(), dataQuery); + + } catch (Exception e){ + final String msg = DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); + } - } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - try { - getConnection().rollback(); - } catch (Exception e2) { - logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); - } - throw new ExceptionDBGitRunTime(e.getMessage()); - } } @Override public DBTableData getTableDataPortion(String schema, String nameTable, int portionIndex, int tryNumber) { - DBTableData data = new DBTableData(); + + final int portionSize = DBGitConfig.getInstance().getInteger( "core", "PORTION_SIZE", + DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000) + ); + + final int dataOffset = portionSize * portionIndex; + final String dataQuery = + "SELECT * " + + "FROM " + schema + "." + nameTable + " " + + "ORDER BY (SELECT NULL) " + + "OFFSET " + dataOffset + " ROWS " + + "FETCH NEXT " + portionSize + " ROWS ONLY "; try { - Statement stmt = getConnection().createStatement(); - int portionSize = DBGitConfig.getInstance().getInteger( "core", "PORTION_SIZE", - DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000) - ); /* For version <= SQL Server 2005 @@ -930,220 +953,209 @@ public DBTableData getTableDataPortion(String schema, String nameTable, int port ); */ - ResultSet rs = stmt.executeQuery( "SELECT * " + - "FROM "+ schema + "." + nameTable + " " + - "ORDER BY (SELECT NULL) " + - "OFFSET " + portionSize*portionIndex + " ROWS " + - "FETCH NEXT " + portionSize + " ROWS ONLY " - ); + return new DBTableData(getConnection(), dataQuery); - data.setResultSet(rs); - return data; } catch (Exception e) { - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("errors", "dataTable", "loadPortionError") - .withParams(String.valueOf(tryNumber)) - , messageLevel - ); - logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - - //try fetch again - try { + final int maxTriesCount = DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000)); + final int tryDelay = DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000)); - int retryDelay = DBGitConfig.getInstance().getInteger( "core", "TRY_DELAY", - DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000) - ); + ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); + ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); + logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - int maxTryCount = DBGitConfig.getInstance().getInteger( "core", "TRY_COUNT", - DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000) - ); + if (tryNumber <= maxTriesCount) { - if (tryNumber <= maxTryCount) { + final String waitMessage = DBGitLang.getInstance() + .getValue("errors", "dataTable", "wait") + .withParams(String.valueOf(tryDelay)); - try { TimeUnit.SECONDS.sleep(retryDelay); } - catch (InterruptedException e1) { throw new ExceptionDBGitRunTime(e1.getMessage()); } + final String tryAgainMessage = DBGitLang.getInstance() + .getValue("errors", "dataTable", "tryAgain") + .withParams(String.valueOf(tryNumber)); - return getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); + ConsoleWriter.println(waitMessage, messageLevel); + try { TimeUnit.SECONDS.sleep(tryDelay); } catch (InterruptedException e1) { + throw new ExceptionDBGitRunTime(e1.getMessage()); } - } catch (Exception e1) { e1.printStackTrace(); } - //rollback, needed only when auto-commit mode has been disabled + ConsoleWriter.println(tryAgainMessage, messageLevel); + return getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); - try { - getConnection().rollback(); - } catch (Exception e2) { - logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); + } else { + final String msg = DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - throw new ExceptionDBGitRunTime(e.getMessage()); } } @Override public Map getUsers() { - Map listUser = new HashMap(); - try { - - String query = - "DECLARE @crlf VARCHAR(2)\n" + - "SELECT \n" + - " u.name userName, sp.name loginName, sp.default_database_name databaseName, dp.default_schema_name as schemaName,\n" + - " CASE WHEN sp.is_disabled IS NULL THEN 1 ELSE sp.is_disabled END isDisabledLogin,\n" + - " CASE WHEN sp.name IS NOT NULL THEN 'CREATE LOGIN [' + sp.name + '] WITH PASSWORD = ' \n" + - " + UPPER(master.dbo.fn_varbintohexstr (CAST(LOGINPROPERTY(sp.name,'PASSWORDHASH') as VARBINARY (256)))) + ' HASHED; ' ELSE '' END \n" + - " + CASE WHEN sp.is_disabled IS NOT NULL AND sp.is_disabled = 0 AND dr.permission_name IS NOT NULL THEN 'GRANT CONNECT SQL TO [' + sp.name + ']; ' ELSE '' END \n" + - " + 'CREATE USER [' + u.name + '] ' \n" + - " + CASE WHEN sp.name IS NOT NULL THEN 'FOR LOGIN [' + sp.name + ']' ELSE '' END\n" + - " + CASE WHEN dp.default_schema_name IS NOT NULL THEN ' WITH DEFAULT_SCHEMA = [' + dp.default_schema_name + ']' ELSE '' END + ';' \n" + - " AS ddl, \n" + - " UPPER(master.dbo.fn_varbintohexstr (CAST(LOGINPROPERTY(sp.name,'PASSWORDHASH') as VARBINARY (256)))) passwordHash\n" + - "FROM sys.sysusers u \n" + - "INNER JOIN sys.database_principals dp ON dp.sid = u.sid\n" + - "LEFT OUTER JOIN sys.server_principals sp ON sp.sid = u.sid\n" + - "LEFT OUTER JOIN sys.database_permissions dr ON dr.grantee_principal_id = dp.principal_id AND dr.permission_name = 'CONNECT'\n" + - "WHERE dp.type_desc = 'SQL_USER' AND u.name NOT IN ('dbo','guest') AND u.name NOT LIKE '##MS%'"; - + final Map listUser = new HashMap(); + final String query = + "DECLARE @crlf VARCHAR(2)\n" + + "SELECT \n" + + " u.name userName, sp.name loginName, sp.default_database_name databaseName, dp.default_schema_name as schemaName,\n" + + " CASE WHEN sp.is_disabled IS NULL THEN 1 ELSE sp.is_disabled END isDisabledLogin,\n" + + " CASE WHEN sp.name IS NOT NULL THEN 'CREATE LOGIN [' + sp.name + '] WITH PASSWORD = ' \n" + + " + UPPER(master.dbo.fn_varbintohexstr (CAST(LOGINPROPERTY(sp.name,'PASSWORDHASH') as VARBINARY (256)))) + ' HASHED; ' ELSE '' END \n" + + " + CASE WHEN sp.is_disabled IS NOT NULL AND sp.is_disabled = 0 AND dr.permission_name IS NOT NULL THEN 'GRANT CONNECT SQL TO [' + sp.name + ']; ' ELSE '' END \n" + + " + 'CREATE USER [' + u.name + '] ' \n" + + " + CASE WHEN sp.name IS NOT NULL THEN 'FOR LOGIN [' + sp.name + ']' ELSE '' END\n" + + " + CASE WHEN dp.default_schema_name IS NOT NULL THEN ' WITH DEFAULT_SCHEMA = [' + dp.default_schema_name + ']' ELSE '' END + ';' \n" + + " AS ddl, \n" + + " UPPER(master.dbo.fn_varbintohexstr (CAST(LOGINPROPERTY(sp.name,'PASSWORDHASH') as VARBINARY (256)))) passwordHash\n" + + "FROM sys.sysusers u \n" + + "INNER JOIN sys.database_principals dp ON dp.sid = u.sid\n" + + "LEFT OUTER JOIN sys.server_principals sp ON sp.sid = u.sid\n" + + "LEFT OUTER JOIN sys.database_permissions dr ON dr.grantee_principal_id = dp.principal_id AND dr.permission_name = 'CONNECT'\n" + + "WHERE dp.type_desc = 'SQL_USER' AND u.name NOT IN ('dbo','guest') AND u.name NOT LIKE '##MS%'"; + + try ( Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query); + ){ while(rs.next()){ - String name = rs.getString(1); - DBUser user = new DBUser(name); - rowToProperties(rs, user.getOptions()); + final String name = rs.getString(1); + final StringProperties options = new StringProperties(rs); + + DBUser user = new DBUser(name, options); listUser.put(name, user); } - stmt.close(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "users") + ": " +e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "users") + ": " + e.getMessage()); + + } catch(Exception e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "users"); + throw new ExceptionDBGitRunTime(msg, e); } + return listUser; } @Override public Map getRoles() { - Map listRole = new HashMap(); - try { - List expressions = Arrays.asList( - "IF OBJECT_ID(N'GetRoleDDL', N'FN') IS NOT NULL DROP FUNCTION GetRoleDDL\n" + - "IF OBJECT_ID(N'GetRoleMembersDDL', N'FN') IS NOT NULL DROP FUNCTION GetRoleMembersDDL\n" - , - "CREATE FUNCTION dbo.GetRoleDDL(@roleName VARCHAR(255))\n" + - "RETURNS VARCHAR(MAX)\n" + - "BEGIN\n" + - " -- Script out the Role\n" + - " DECLARE @roleDesc VARCHAR(MAX)\n" + - " SET @roleDesc = 'CREATE ROLE [' + @roleName + '];'\n" + - " DECLARE @rolePerm VARCHAR(MAX)\n" + - " SET @rolePerm = ''\n" + - " SELECT @rolePerm = @rolePerm +\n" + - " CASE dp.state\n" + - " WHEN 'D' THEN 'DENY '\n" + - " WHEN 'G' THEN 'GRANT '\n" + - " WHEN 'R' THEN 'REVOKE '\n" + - " WHEN 'W' THEN 'GRANT '\n" + - " END + \n" + - " dp.permission_name + ' ' +\n" + - " CASE dp.class\n" + - " WHEN 0 THEN ''\n" + - " WHEN 1 THEN --table or column subset on the table\n" + - " CASE WHEN dp.major_id < 0 THEN\n" + - " + 'ON [sys].[' + OBJECT_NAME(dp.major_id) + '] '\n" + - " ELSE\n" + - " + 'ON [' +\n" + - " (SELECT SCHEMA_NAME(schema_id) + '].[' + name FROM sys.objects WHERE object_id = dp.major_id)\n" + - " + -- optionally concatenate column names\n" + - " CASE WHEN MAX(dp.minor_id) > 0 \n" + - " THEN '] ([' + REPLACE(\n" + - " (SELECT name + '], [' \n" + - " FROM sys.columns \n" + - " WHERE object_id = dp.major_id \n" + - " AND column_id IN (SELECT minor_id \n" + - " FROM sys.database_permissions \n" + - " WHERE major_id = dp.major_id\n" + - " AND USER_NAME(grantee_principal_id) IN (@roleName)\n" + - " )\n" + - " FOR XML PATH('')\n" + - " ) --replace final square bracket pair\n" + - " + '])', ', []', '')\n" + - " ELSE ']'\n" + - " END + ' '\n" + - " END\n" + - " WHEN 3 THEN 'ON SCHEMA::[' + SCHEMA_NAME(dp.major_id) + '] '\n" + - " WHEN 4 THEN 'ON ' + (SELECT RIGHT(type_desc, 4) + '::[' + name FROM sys.database_principals WHERE principal_id = dp.major_id) + '] '\n" + - " WHEN 5 THEN 'ON ASSEMBLY::[' + (SELECT name FROM sys.assemblies WHERE assembly_id = dp.major_id) + '] '\n" + - " WHEN 6 THEN 'ON TYPE::[' + (SELECT name FROM sys.types WHERE user_type_id = dp.major_id) + '] '\n" + - " WHEN 10 THEN 'ON XML SCHEMA COLLECTION::[' + (SELECT SCHEMA_NAME(schema_id) + '.' + name FROM sys.xml_schema_collections WHERE xml_collection_id = dp.major_id) + '] '\n" + - " WHEN 15 THEN 'ON MESSAGE TYPE::[' + (SELECT name FROM sys.service_message_types WHERE message_type_id = dp.major_id) + '] '\n" + - " WHEN 16 THEN 'ON CONTRACT::[' + (SELECT name FROM sys.service_contracts WHERE service_contract_id = dp.major_id) + '] '\n" + - " WHEN 17 THEN 'ON SERVICE::[' + (SELECT name FROM sys.services WHERE service_id = dp.major_id) + '] '\n" + - " WHEN 18 THEN 'ON REMOTE SERVICE BINDING::[' + (SELECT name FROM sys.remote_service_bindings WHERE remote_service_binding_id = dp.major_id) + '] '\n" + - " WHEN 19 THEN 'ON ROUTE::[' + (SELECT name FROM sys.routes WHERE route_id = dp.major_id) + '] '\n" + - " WHEN 23 THEN 'ON FULLTEXT CATALOG::[' + (SELECT name FROM sys.fulltext_catalogs WHERE fulltext_catalog_id = dp.major_id) + '] '\n" + - " WHEN 24 THEN 'ON SYMMETRIC KEY::[' + (SELECT name FROM sys.symmetric_keys WHERE symmetric_key_id = dp.major_id) + '] '\n" + - " WHEN 25 THEN 'ON CERTIFICATE::[' + (SELECT name FROM sys.certificates WHERE certificate_id = dp.major_id) + '] '\n" + - " WHEN 26 THEN 'ON ASYMMETRIC KEY::[' + (SELECT name FROM sys.asymmetric_keys WHERE asymmetric_key_id = dp.major_id) + '] '\n" + - " END COLLATE SQL_Latin1_General_CP1_CI_AS\n" + - " + 'TO [' + @roleName + ']' + \n" + - " CASE dp.state WHEN 'W' THEN ' WITH GRANT OPTION' ELSE '' END + ';'\n" + - " FROM sys.database_permissions dp\n" + - " WHERE USER_NAME(dp.grantee_principal_id) IN (@roleName)\n" + - " GROUP BY dp.state, dp.major_id, dp.permission_name, dp.class\n" + - " SELECT @roleDesc = @roleDesc + CASE WHEN @rolePerm IS NOT NULL THEN @rolePerm ELSE '' END\n" + - " RETURN @roleDesc\n" + - "END \n" - , - "CREATE FUNCTION dbo.GetRoleMembersDDL(@roleName VARCHAR(255))\n" + - "RETURNS VARCHAR(MAX)\n" + - "BEGIN\n" + - " -- Script out the Role\n" + - " DECLARE @roleDesc VARCHAR(MAX)\n" + - " SET @roleDesc = ''\n" + - " -- Display users within Role. Code stubbed by Joe Spivey\n" + - " SELECT @roleDesc = @roleDesc + 'EXECUTE sp_AddRoleMember ''' + roles.name + ''', ''' + users.name + ''';' \n" + - " FROM sys.database_principals users\n" + - " INNER JOIN sys.database_role_members link \n" + - " ON link.member_principal_id = users.principal_id\n" + - " INNER JOIN sys.database_principals roles \n" + - " ON roles.principal_id = link.role_principal_id\n" + - " WHERE roles.name = @roleName\n" + - " RETURN @roleDesc\n" + - "END \n" - ); + final Map listRole = new HashMap(); + final String usersQuery = + "SELECT \n" + + " dp.name roleName, dp.is_fixed_role isFixedRole,\n" + + " CASE WHEN dp.is_fixed_role = 0 AND dp.name != 'public' THEN dbo.GetRoleDDL(dp.name) ELSE '' " + + " END roleDDL,\n" + + " dbo.GetRoleMembersDDL(dp.name) membersDDL,\n" + + " CASE WHEN dp.is_fixed_role = 1 OR dp.name = 'public'" + + " THEN dbo.GetRoleMembersDDL(dp.name) " + + " ELSE dbo.GetRoleDDL(dp.name) + dbo.GetRoleMembersDDL(dp.name) " + + " END ddl\n" + + "FROM sys.database_principals dp\n" + + "WHERE dp.type = 'R'\n" + + "DROP FUNCTION GetRoleDDL\n" + + "DROP FUNCTION GetRoleMembersDDL"; + + List setupQueries = Arrays.asList( + "IF OBJECT_ID(N'GetRoleDDL', N'FN') IS NOT NULL DROP FUNCTION GetRoleDDL\n" + + "IF OBJECT_ID(N'GetRoleMembersDDL', N'FN') IS NOT NULL DROP FUNCTION GetRoleMembersDDL\n" + , + "CREATE FUNCTION dbo.GetRoleDDL(@roleName VARCHAR(255))\n" + + "RETURNS VARCHAR(MAX)\n" + + "BEGIN\n" + + " -- Script out the Role\n" + + " DECLARE @roleDesc VARCHAR(MAX)\n" + + " SET @roleDesc = 'CREATE ROLE [' + @roleName + '];'\n" + + " DECLARE @rolePerm VARCHAR(MAX)\n" + + " SET @rolePerm = ''\n" + + " SELECT @rolePerm = @rolePerm +\n" + + " CASE dp.state\n" + + " WHEN 'D' THEN 'DENY '\n" + + " WHEN 'G' THEN 'GRANT '\n" + + " WHEN 'R' THEN 'REVOKE '\n" + + " WHEN 'W' THEN 'GRANT '\n" + + " END + \n" + + " dp.permission_name + ' ' +\n" + + " CASE dp.class\n" + + " WHEN 0 THEN ''\n" + + " WHEN 1 THEN --table or column subset on the table\n" + + " CASE WHEN dp.major_id < 0 THEN\n" + + " + 'ON [sys].[' + OBJECT_NAME(dp.major_id) + '] '\n" + + " ELSE\n" + + " + 'ON [' +\n" + + " (SELECT SCHEMA_NAME(schema_id) + '].[' + name FROM sys.objects WHERE object_id = dp.major_id)\n" + + " + -- optionally concatenate column names\n" + + " CASE WHEN MAX(dp.minor_id) > 0 \n" + + " THEN '] ([' + REPLACE(\n" + + " (SELECT name + '], [' \n" + + " FROM sys.columns \n" + + " WHERE object_id = dp.major_id \n" + + " AND column_id IN (SELECT minor_id \n" + + " FROM sys.database_permissions \n" + + " WHERE major_id = dp.major_id\n" + + " AND USER_NAME(grantee_principal_id) IN (@roleName)\n" + + " )\n" + + " FOR XML PATH('')\n" + + " ) --replace final square bracket pair\n" + + " + '])', ', []', '')\n" + + " ELSE ']'\n" + + " END + ' '\n" + + " END\n" + + " WHEN 3 THEN 'ON SCHEMA::[' + SCHEMA_NAME(dp.major_id) + '] '\n" + + " WHEN 4 THEN 'ON ' + (SELECT RIGHT(type_desc, 4) + '::[' + name FROM sys.database_principals WHERE principal_id = dp.major_id) + '] '\n" + + " WHEN 5 THEN 'ON ASSEMBLY::[' + (SELECT name FROM sys.assemblies WHERE assembly_id = dp.major_id) + '] '\n" + + " WHEN 6 THEN 'ON TYPE::[' + (SELECT name FROM sys.types WHERE user_type_id = dp.major_id) + '] '\n" + + " WHEN 10 THEN 'ON XML SCHEMA COLLECTION::[' + (SELECT SCHEMA_NAME(schema_id) + '.' + name FROM sys.xml_schema_collections WHERE xml_collection_id = dp.major_id) + '] '\n" + + " WHEN 15 THEN 'ON MESSAGE TYPE::[' + (SELECT name FROM sys.service_message_types WHERE message_type_id = dp.major_id) + '] '\n" + + " WHEN 16 THEN 'ON CONTRACT::[' + (SELECT name FROM sys.service_contracts WHERE service_contract_id = dp.major_id) + '] '\n" + + " WHEN 17 THEN 'ON SERVICE::[' + (SELECT name FROM sys.services WHERE service_id = dp.major_id) + '] '\n" + + " WHEN 18 THEN 'ON REMOTE SERVICE BINDING::[' + (SELECT name FROM sys.remote_service_bindings WHERE remote_service_binding_id = dp.major_id) + '] '\n" + + " WHEN 19 THEN 'ON ROUTE::[' + (SELECT name FROM sys.routes WHERE route_id = dp.major_id) + '] '\n" + + " WHEN 23 THEN 'ON FULLTEXT CATALOG::[' + (SELECT name FROM sys.fulltext_catalogs WHERE fulltext_catalog_id = dp.major_id) + '] '\n" + + " WHEN 24 THEN 'ON SYMMETRIC KEY::[' + (SELECT name FROM sys.symmetric_keys WHERE symmetric_key_id = dp.major_id) + '] '\n" + + " WHEN 25 THEN 'ON CERTIFICATE::[' + (SELECT name FROM sys.certificates WHERE certificate_id = dp.major_id) + '] '\n" + + " WHEN 26 THEN 'ON ASYMMETRIC KEY::[' + (SELECT name FROM sys.asymmetric_keys WHERE asymmetric_key_id = dp.major_id) + '] '\n" + + " END COLLATE SQL_Latin1_General_CP1_CI_AS\n" + + " + 'TO [' + @roleName + ']' + \n" + + " CASE dp.state WHEN 'W' THEN ' WITH GRANT OPTION' ELSE '' END + ';'\n" + + " FROM sys.database_permissions dp\n" + + " WHERE USER_NAME(dp.grantee_principal_id) IN (@roleName)\n" + + " GROUP BY dp.state, dp.major_id, dp.permission_name, dp.class\n" + + " SELECT @roleDesc = @roleDesc + CASE WHEN @rolePerm IS NOT NULL THEN @rolePerm ELSE '' END\n" + + " RETURN @roleDesc\n" + + "END \n" + , + "CREATE FUNCTION dbo.GetRoleMembersDDL(@roleName VARCHAR(255))\n" + + "RETURNS VARCHAR(MAX)\n" + + "BEGIN\n" + + " -- Script out the Role\n" + + " DECLARE @roleDesc VARCHAR(MAX)\n" + + " SET @roleDesc = ''\n" + + " -- Display users within Role. Code stubbed by Joe Spivey\n" + + " SELECT @roleDesc = @roleDesc + 'EXECUTE sp_AddRoleMember ''' + roles.name + ''', ''' + users.name + ''';' \n" + + " FROM sys.database_principals users\n" + + " INNER JOIN sys.database_role_members link \n" + + " ON link.member_principal_id = users.principal_id\n" + + " INNER JOIN sys.database_principals roles \n" + + " ON roles.principal_id = link.role_principal_id\n" + + " WHERE roles.name = @roleName\n" + + " RETURN @roleDesc\n" + + "END \n" + ); - String query = - "SELECT \n" + - " dp.name roleName, dp.is_fixed_role isFixedRole,\n" + - " CASE WHEN dp.is_fixed_role = 0 AND dp.name != 'public' THEN dbo.GetRoleDDL(dp.name) ELSE '' " + - " END roleDDL,\n" + - " dbo.GetRoleMembersDDL(dp.name) membersDDL,\n" + - " CASE WHEN dp.is_fixed_role = 1 OR dp.name = 'public'" + - " THEN dbo.GetRoleMembersDDL(dp.name) " + - " ELSE dbo.GetRoleDDL(dp.name) + dbo.GetRoleMembersDDL(dp.name) " + - " END ddl\n" + - "FROM sys.database_principals dp\n" + - "WHERE dp.type = 'R'\n" + - "DROP FUNCTION GetRoleDDL\n" + - "DROP FUNCTION GetRoleMembersDDL"; - - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); - - for(String expr : expressions){ + try (Statement stmt = getConnection().createStatement();) { + + for(String expr : setupQueries){ stmt.execute(expr); } - ResultSet rs = stmt.executeQuery(query); - while(rs.next()){ - String name = rs.getString("rolename"); - DBRole role = new DBRole(name); - rowToProperties(rs, role.getOptions()); - listRole.put(name, role); + try(ResultSet rs = stmt.executeQuery(usersQuery);){ + while(rs.next()){ + final String name = rs.getString("rolename"); + final StringProperties options = new StringProperties(rs); + + DBRole role = new DBRole(name, options); + listRole.put(name, role); + } } - stmt.close(); + }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "roles") + ": " + e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "roles") + ": " + e.getMessage()); + final DBGitLang msg = lang.getValue("errors", "adapter", "roles"); + throw new ExceptionDBGitRunTime(msg, e); } return listRole; } diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java index 70c6498..cd0e06a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableDataMssql.java @@ -61,7 +61,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if (getAdapter().getTable(schema, currentTableData.getTable().getName()) != null) { currentTableData.setDataTable(getAdapter().getTableData(schema, currentTableData.getTable().getName())); - ResultSet rs = currentTableData.getDataTable().getResultSet(); + ResultSet rs = currentTableData.getDataTable().resultSet(); TreeMapRowData mapRows = new TreeMapRowData(); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java index fc11dc9..774fe87 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java @@ -7,12 +7,10 @@ import java.sql.SQLException; import java.sql.Statement; import java.text.MessageFormat; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.concurrent.TimeUnit; +import com.google.common.collect.ImmutableMap; import org.apache.commons.lang3.exception.ExceptionUtils; import org.slf4j.Logger; @@ -22,17 +20,9 @@ import ru.fusionsoft.dbgit.adapters.IFactoryDBAdapterRestoteMetaData; import ru.fusionsoft.dbgit.adapters.IFactoryDBBackupAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; -import ru.fusionsoft.dbgit.core.DBGitConfig; -import ru.fusionsoft.dbgit.core.DBGitLang; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; +import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.core.db.FieldType; -import ru.fusionsoft.dbgit.data_table.DateData; -import ru.fusionsoft.dbgit.data_table.FactoryCellData; -import ru.fusionsoft.dbgit.data_table.LongData; -import ru.fusionsoft.dbgit.data_table.MapFileData; -import ru.fusionsoft.dbgit.data_table.StringData; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; import ru.fusionsoft.dbgit.dbobjects.DBFunction; import ru.fusionsoft.dbgit.dbobjects.DBIndex; @@ -49,6 +39,7 @@ import ru.fusionsoft.dbgit.dbobjects.DBUser; import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMapMetaObject; +import ru.fusionsoft.dbgit.meta.TreeMapMetaObject; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; @@ -60,7 +51,7 @@ public class DBAdapterMySql extends DBAdapter { private FactoryDBRestoreAdapterMySql restoreFactory = new FactoryDBRestoreAdapterMySql(); private FactoryDBConvertAdapterMySql convertFactory = new FactoryDBConvertAdapterMySql(); private FactoryDBBackupAdapterMySql backupFactory = new FactoryDBBackupAdapterMySql(); - public static Set reservedWords; + public final static Set reservedWords = new HashSet<>(); public String escapeNameIfNeeded(String name) { boolean shouldBeEscaped = false; @@ -82,42 +73,119 @@ public String escapeNameIfNeeded(String name) { public IFactoryDBAdapterRestoteMetaData getFactoryRestore() { return restoreFactory; } + @Override + public IFactoryDBConvertAdapter getConvertAdapterFactory() { + return convertFactory; + } + @Override + public IFactoryDBBackupAdapter getBackupAdapterFactory() { + return backupFactory; + } @Override - public void startUpdateDB() { + public boolean userHasRightsToGetDdlOfOtherUsers() { + return true; + } + + @Override + public DbType getDbType() { + return DbType.MYSQL; + } + @Override + public String getDbVersion() { + try ( + PreparedStatement stmt = getConnection().prepareStatement("SELECT version()"); + ResultSet resultSet = stmt.executeQuery(); + ) { + if(!resultSet.next()) throw new ExceptionDBGitRunTime("failed to get db version resultset"); + final String result = resultSet.getString(1); + + return result; + } catch (SQLException e) { + throw new ExceptionDBGitRunTime("failed to get db version resultset"); + } + } + @Override + public String getDefaultScheme() { + try { + return getConnection().getCatalog(); + } catch (SQLException e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "getSchema"); + throw new ExceptionDBGitRunTime(msg); + } + } + + @Override + public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit { + final String query = + "select count(*) cnt " + + "from information_schema.schemata " + + "where upper(schema_name) = '" + schemaName.toUpperCase() + "'"; + + try ( + Statement st = connect.createStatement(); + ResultSet rs = st.executeQuery(query); + ) { + + if(!rs.next()) throw new ExceptionDBGitRunTime("failed to get schemas count resultset"); + + if (rs.getInt("cnt") == 0){ + try(StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql());) { + stLog.execute("create schema " + schemaName); + } + } + + } catch (SQLException e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "createSchema"); + throw new ExceptionDBGit(msg); + } + } + @Override + public void createRoleIfNeed(String roleName) throws ExceptionDBGit { // TODO Auto-generated method stub } + @Override + public boolean isReservedWord(String word) { + return reservedWords.contains(word.toUpperCase()); + } + + @Override + public void startUpdateDB() { + // TODO Auto-generated method stub + } @Override public void endUpdateDB() { // TODO Auto-generated method stub - } @Override public IMapMetaObject loadCustomMetaObjects() { - return null; + return new TreeMapMetaObject(Collections.emptyList()); } @Override public Map getSchemes() { - String query = + final Map listScheme = new HashMap(); + final String query = "select schema_name\r\n" + "from information_schema.schemata"; - Map listScheme = new HashMap(); - try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + try ( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ){ while(rs.next()){ - String name = rs.getString("schema_name"); - DBSchema scheme = new DBSchema(name); - rowToProperties(rs, scheme.getOptions()); - listScheme.put(name, scheme); - } + final String name = rs.getString("schema_name"); + final DBSchema scheme = new DBSchema(name, new StringProperties(rs)); + listScheme.put(name, scheme); + } + } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "schemes").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "schemes").toString(), e); + final String msg = lang.getValue("errors", "adapter", "schemes").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listScheme; @@ -125,97 +193,126 @@ public Map getSchemes() { @Override public Map getTableSpaces() { - // TODO Auto-generated method stub - return null; + return Collections.emptyMap(); } @Override public Map getSequences(String schema) { - Map sequences = new HashMap(); - - String query = - "select column_name, table_name, column_type, extra from information_schema.columns" + + final Map sequences = new HashMap<>(); + final String query = + " select column_name, table_name, column_type, extra " + + " from information_schema.columns" + " where extra like '%auto_increment%' and table_schema='" + schema + "'"; - try(Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - String valueQuery = - "select coalesce(max(" + rs.getString("column_name") + "), 0) as nextval" + - " from " + schema + ".`" + rs.getString("table_name") + "`"; + try( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ) { while(rs.next()) { - try(Statement stmtValue = connect.createStatement(); ResultSet rsValue = stmtValue.executeQuery(valueQuery)){ - rsValue.next(); - String name = rs.getString("column_name"); - Long value = rsValue.getLong("nextval"); - DBSequence seq = new DBSequence(name, schema, value); - sequences.put(name, seq); + final String valueQuery = + " select coalesce(max(" + rs.getString("column_name") + "), 0) as nextval" + + " from " + schema + ".`" + rs.getString("table_name") + "`"; + + try(Statement stmtValue = getConnection().createStatement(); ResultSet rsValue = stmtValue.executeQuery(valueQuery)){ + if(rsValue.next()){ + final String name = rs.getString("column_name"); + final String owner = ""; + final Long value = rsValue.getLong("nextval"); + final DBSequence seq = new DBSequence(name, new StringProperties(rs), schema, owner, Collections.emptySet(), value); + sequences.put(name, seq); + } } } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "seq").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "seq").toString(), e); + final String msg = lang.getValue("errors", "adapter", "seq").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return sequences; } @Override public DBSequence getSequence(String schema, String name) { - String query = + final String query = "select column_name, table_name, column_type, extra from information_schema.columns" + " where extra like '%auto_increment%' and table_schema='" + schema + "' and column_name='" + name + "'"; - DBSequence seq = null; - try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + try ( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ){ if(rs.next()) { - - String valueQuery = + final String valueQuery = "select coalesce(max(" + rs.getString("column_name") + "), 0) as nextval" + " from " + schema + ".`" + rs.getString("table_name") + "`"; - try(Statement stmtValue = connect.createStatement(); ResultSet rsValue = stmtValue.executeQuery(valueQuery)){ - rsValue.next(); - Long value = rsValue.getLong("nextval"); - seq = new DBSequence(name, schema, value); + try( + Statement stmtValue = connect.createStatement(); + ResultSet rsValue = stmtValue.executeQuery(valueQuery) + ){ + if(!rsValue.next()) throw new ExceptionDBGitRunTime("failed to get seq value resultset"); + + final String nameSeq = rs.getString("column_name"); + final String ownerSeq = ""; + final Long valueSeq = rsValue.getLong("nextval"); + + return new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); } + } else { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } } catch (Exception e) { - logger.error(lang.getValue("errors", "adapter", "seq").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "seq").toString(), e); + final String msg = lang.getValue("errors", "adapter", "seq").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return seq; } @Override public Map getTables(String schema) { - Map listTable = new HashMap(); - String query = + final Map listTable = new HashMap<>(); + final String query = "SELECT T.TABLE_NAME, T.TABLE_SCHEMA " + "FROM information_schema.tables T WHERE TABLE_SCHEMA = '" + schema + "' and TABLE_TYPE = 'BASE TABLE'"; - try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);){ + try ( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ){ while(rs.next()){ - String nameTable = rs.getString("TABLE_NAME"); //TODO retrieve table comment - DBTable table = new DBTable(nameTable, schema, null); - rowToProperties(rs, table.getOptions()); + //TODO retrieve table owner + + final String nameTable = rs.getString("TABLE_NAME"); + final String ownerTable = ""; + final String commentTable = ""; + final String ddlQuery = "show create table " + schema + ".`" + nameTable + "`"; + final StringProperties options = new StringProperties(rs); + final Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); + + try( + Statement stmtDdl = getConnection().createStatement(); + ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery); + ){ + if(!rsDdl.next()) throw new ExceptionDBGitRunTime("failed to get table ddl resultset"); + options.addChild("ddl", cleanString(rsDdl.getString(2))); + } - String ddlQuery = "show create table " + schema + ".`" + nameTable + "`"; - try(Statement stmtDdl = connect.createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ - rsDdl.next(); - table.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); - listTable.put(nameTable, table); + final DBTable table = new DBTable(nameTable, options, schema, ownerTable, dependencies, commentTable); + listTable.put(nameTable, table); - } } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + final String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listTable; @@ -223,121 +320,138 @@ public Map getTables(String schema) { @Override public DBTable getTable(String schema, String name) { - String query = + final String query = "SELECT T.TABLE_NAME, T.TABLE_SCHEMA FROM information_schema.tables T" + " WHERE TABLE_SCHEMA = '" + schema + "'" + " AND T.TABLE_NAME = '" + name + "'"; - DBTable table = null; - try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);){ - while(rs.next()) { - String nameTable = rs.getString("TABLE_NAME"); - String ddlQuery = "show create table " + schema + ".`" + nameTable + "`"; - table = new DBTable(nameTable, schema, null); - - try(Statement stmtDdl = connect.createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ + if (rs.next()){ + //TODO retrieve table comment + //TODO retrieve table owner + final String nameTable = rs.getString("TABLE_NAME"); + final String ownerTable = ""; + final String commentTable = ""; + final StringProperties options = new StringProperties(rs); + final Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); + + final String ddlQuery = "show create table " + schema + ".`" + nameTable + "`"; + try(Statement stmtDdl = getConnection().createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ rsDdl.next(); - table.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); - rowToProperties(rs, table.getOptions()); + options.addChild("ddl", cleanString(rsDdl.getString(2))); } + return new DBTable(nameTable, options, schema, ownerTable, dependencies, commentTable); + + } else { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return table; } @Override public Map getTableFields(String schema, String nameTable) { - - Map listField = new HashMap(); - - String query = - "SELECT distinct col.column_name,col.is_nullable,col.data_type,col.character_maximum_length, tc.constraint_name, " + - "case\r\n" + - " when lower(data_type) in ('tinyint', 'smallint', 'mediumint', 'int', 'bigint', 'float', 'double', 'decimal') then 'number' \r\n" + - " when lower(data_type) in ('tinytext', 'text', 'char', 'mediumtext', 'longtext', 'varchar') then 'string'\r\n" + - " when lower(data_type) in ('datetime', 'timestamp', 'date') then 'date'\r\n" + - " when lower(data_type) in ('boolean') then 'boolean'\r\n" + - " when lower(data_type) in ('blob', 'mediumblob', 'longblob', 'binary', 'varbinary') then 'binary'" + - " else 'native'\r\n" + + final Map listField = new HashMap(); + final String query = + "SELECT DISTINCT " + + " col.column_name, col.is_nullable, col.data_type, col.character_maximum_length, tc.constraint_name, " + + " case\r\n" + + " when lower(data_type) in ('tinyint', 'smallint', 'mediumint', 'int', 'bigint', 'float', 'double', 'decimal') then 'number' \r\n" + + " when lower(data_type) in ('tinytext', 'text', 'char', 'mediumtext', 'longtext', 'varchar') then 'string'\r\n" + + " when lower(data_type) in ('datetime', 'timestamp', 'date') then 'date'\r\n" + + " when lower(data_type) in ('boolean') then 'boolean'\r\n" + + " when lower(data_type) in ('blob', 'mediumblob', 'longblob', 'binary', 'varbinary') then 'binary'" + + " else 'native'\r\n" + " end tp, " + - " case when lower(data_type) in ('char', 'character') then true else false end fixed, " + - "col.* FROM " + - "information_schema.columns col " + - "left join information_schema.key_column_usage kc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and col.column_name=kc.column_name " + - "left join information_schema.table_constraints tc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and kc.constraint_name = tc.constraint_name and tc.constraint_type = 'PRIMARY KEY' " + - "where col.table_schema = :schema and col.table_name = :table " + - "order by col.column_name "; + " case " + + " when lower(data_type) in ('char', 'character') " + + " then true else false " + + " end fixed, " + + " col.* " + + "FROM information_schema.columns col " + + "LEFT JOIN information_schema.key_column_usage kc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and col.column_name=kc.column_name " + + "LEFT JOIN information_schema.table_constraints tc on col.table_schema = kc.table_schema and col.table_name = kc.table_name and kc.constraint_name = tc.constraint_name and tc.constraint_type = 'PRIMARY KEY' " + + "WHERE col.table_schema = :schema and col.table_name = :table " + + "ORDER BY col.column_name "; + + try ( + PreparedStatement stmt = preparedStatement(getConnection(), query, ImmutableMap.of("schema", schema, "table", nameTable)); + ResultSet rs = stmt.executeQuery(); + ) { - try (NamedParameterPreparedStatement stmt = getParamStatement(query, getConnection()); ResultSet rs = stmt.executeQuery();){ + while(rs.next()){ - stmt.setString("schema", schema); - stmt.setString("table", nameTable); + //TODO make restore defaultValue, description (comment) and order in MySQL + final String columnName = rs.getString("column_name").toLowerCase(); + final String typeSQL = getFieldType(rs); + final FieldType typeUniversal = FieldType.fromString(rs.getString("tp")); + final String defaultValue = rs.getString("column_name") != null ? rs.getString("column_name").toLowerCase() : ""; + final String description = rs.getString("column_comment") != null ? rs.getString("column_comment").toLowerCase() : ""; + final int order = rs.getInt("ordinal_position"); + final boolean isPrimaryKey = rs.getString("constraint_name") != null; + final boolean isFixed = rs.getBoolean("isFixed"); + final boolean isNullable = !typeSQL.toLowerCase().contains("not null"); + final int length = rs.getInt("character_maximum_length"); + final int precision = rs.getInt("numeric_precision"); + final int scale = rs.getInt("numeric_scale"); + + final DBTableField field = new DBTableField( + columnName, description, isPrimaryKey, isNullable, + typeSQL, typeUniversal, order, defaultValue, + length, scale, precision, isFixed + ); - while(rs.next()){ - DBTableField field = new DBTableField(); - field.setName(rs.getString("column_name").toLowerCase()); - if (rs.getString("constraint_name") != null) { - field.setIsPrimaryKey(true); - } - String typeSQL = getFieldType(rs); - field.setTypeSQL(typeSQL); - field.setIsNullable( !typeSQL.toLowerCase().contains("not null")); - field.setTypeUniversal(FieldType.fromString(rs.getString("tp"))); - field.setFixed(false); - field.setLength(rs.getInt("character_maximum_length")); - field.setPrecision(rs.getInt("numeric_precision")); - field.setScale(rs.getInt("numeric_scale")); - field.setFixed(rs.getBoolean("fixed")); listField.put(field.getName(), field); } - stmt.close(); - - return listField; - } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); - } - } + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); + } + return listField; + } @Override public Map getIndexes(String schema, String nameTable) { - Map indexes = new HashMap<>(); + final Map indexes = new HashMap<>(); + final String query = + "select TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE, GROUP_CONCAT(COLUMN_NAME separator '`, `') as FIELDS " + + "from INFORMATION_SCHEMA.STATISTICS where TABLE_SCHEMA = '" + schema + "' and INDEX_NAME != 'PRIMARY' " + + "group by TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE order by TABLE_NAME, INDEX_NAME;"; - String query = "select TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE, GROUP_CONCAT(COLUMN_NAME separator '`, `') as FIELDS " - + "from INFORMATION_SCHEMA.STATISTICS where TABLE_SCHEMA = '" + schema + "' and INDEX_NAME != 'PRIMARY' " - + "group by TABLE_NAME, INDEX_NAME, INDEX_TYPE, NON_UNIQUE order by TABLE_NAME, INDEX_NAME;"; + try( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ) { - try(Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()) { //TODO find real owner - DBIndex index = new DBIndex(rs.getString("INDEX_NAME"), schema, schema); - rowToProperties(rs, index.getOptions()); - - String ddl = + final String indexName = rs.getString("INDEX_NAME"); + final String sql = cleanString( "create " + (rs.getInt("NON_UNIQUE") == 1 ? "" : "unique ") - + "index `" + rs.getString("INDEX_NAME") + + "index `" + indexName + "` using " + rs.getString("INDEX_TYPE") + " on " + schema + ".`" + rs.getString("TABLE_NAME") + "`" - + "(`" + rs.getString("FIELDS") + "`)"; + + "(`" + rs.getString("FIELDS") + "`)" + ); - index.getOptions().addChild("ddl", cleanString(ddl)); - indexes.put(rs.getString("INDEX_NAME"), index); + final DBIndex index = new DBIndex(indexName, new StringProperties(rs), schema, schema, Collections.emptySet(), sql); + indexes.put(indexName, index); } } catch(Exception e) { - logger.error(e.getMessage()); - System.out.println(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); + final String msg = lang.getValue("errors", "adapter", "indexes").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return indexes; @@ -345,35 +459,45 @@ public Map getIndexes(String schema, String nameTable) { @Override public Map getConstraints(String schema, String nameTable) { - Map constraints = new HashMap<>(); - return constraints; + return Collections.emptyMap(); } @Override public Map getViews(String schema) { - Map listView = new HashMap(); - String query = "show full tables in " + schema + " where TABLE_TYPE like 'VIEW'"; + final Map listView = new HashMap(); + final String query = "show full tables in " + schema + " where TABLE_TYPE like 'VIEW'"; - try (Statement stmt = getConnection().createStatement();ResultSet rs = stmt.executeQuery(query);) { + try ( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ) { - String name = rs.getString(1); - String ddlQuery = "show create view " + schema + "." + name; while(rs.next()){ + //TODO try find real owner - DBView view = new DBView(name, schema, schema); - rowToProperties(rs, view.getOptions()); - - try(Statement stmtDdl = getConnection().createStatement();ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ - rsDdl.next(); - view.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); - listView.put(name, view); + final String name = rs.getString(1); + final String ddlQuery = "show create view " + schema + "." + name; + String sql = ""; + + try( + Statement stmtDdl = getConnection().createStatement(); + ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery); + ){ + if(rsDdl.next()){ + sql = cleanString(rsDdl.getString(2)); + } else { + String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } } + + final DBView view = new DBView(name, new StringProperties(rs), schema, schema, Collections.emptySet(), sql); + listView.put(name, view); } } catch(Exception e) { - logger.error(e.getMessage()); - System.out.println(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); + final DBGitLang msg = lang.getValue("errors", "adapter", "views"); + throw new ExceptionDBGitRunTime(msg, e); } return listView; @@ -383,52 +507,52 @@ public Map getViews(String schema) { @Override public DBView getView(String schema, String name) { //TODO find real owner - String query = "show create view " + schema + ".`" + name + "`"; - DBView view = new DBView(name, schema, schema); + final String query = "show create view " + schema + ".`" + name + "`"; - try (Statement stmtDdl = getConnection().createStatement();ResultSet rsDdl = stmtDdl.executeQuery(query);){ + try ( + Statement stmtDdl = getConnection().createStatement(); + ResultSet rsDdl = stmtDdl.executeQuery(query); + ) { if(rsDdl.next()) { - view.getOptions().addChild("ddl", cleanString(rsDdl.getString(2))); + final String sql = cleanString(rsDdl.getString(2)); + return new DBView(name, new StringProperties(rsDdl), schema, schema, Collections.emptySet(), sql); + } else { + String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } } catch(Exception e) { - logger.error(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); + final DBGitLang msg = lang.getValue("errors", "adapter", "views"); + throw new ExceptionDBGitRunTime(msg, e); } - return view; } @Override public Map getPackages(String schema) { - Map packages = new HashMap(); - return packages; + return Collections.emptyMap(); } @Override public DBPackage getPackage(String schema, String name) { - // TODO Auto-generated method stub - return null; + throw new ExceptionDBGitRunTime(new ExceptionDBGitObjectNotFound("cannot get packages on mysql")); } @Override public Map getProcedures(String schema) { - Map procedures = new HashMap(); - return procedures; + return Collections.emptyMap(); } @Override public DBProcedure getProcedure(String schema, String name) { - // TODO Auto-generated method stub - return null; + throw new ExceptionDBGitRunTime(new ExceptionDBGitObjectNotFound("cannot get procedure on mysql")); } @Override public Map getFunctions(String schema) { - Map listFunction = new HashMap(); - - String query = + final Map listFunction = new HashMap(); + final String query = "SELECT R.routine_schema as \"schema\", R.definer as \"rolname\", R.specific_name as \"name\"," + "group_concat(concat(P.parameter_name, \" \", P.data_type)) as \"arguments\", R.routine_definition as \"ddl\"\r\n" + "FROM information_schema.routines as R, information_schema.parameters as P\r\n" + @@ -436,14 +560,17 @@ public Map getFunctions(String schema) { "P.specific_name=R.specific_name and R.routine_type='FUNCTION' and R.routine_schema='" + schema + "'" + " GROUP BY R.specific_name,1,2,5,P.ordinal_position ORDER BY P.ordinal_position"; - try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + try ( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ) { while(rs.next()) { - String name = rs.getString("name"); - String owner = rs.getString("rolname"); + final String name = rs.getString("name"); + final String owner = rs.getString("rolname"); + final String sql = rs.getString("ddl"); - DBFunction func = new DBFunction(name, schema, owner); - rowToProperties(rs, func.getOptions()); + DBFunction func = new DBFunction(name, new StringProperties(rs), schema, owner, Collections.emptySet(), sql); //String args = rs.getString("arguments"); //func.setArguments(args); listFunction.put(name, func); @@ -458,9 +585,9 @@ public Map getFunctions(String schema) { @Override public DBFunction getFunction(String schema, String name) { - DBFunction function = null; + final DBFunction function = null; - String query = + final String query = "SELECT R.routine_schema as \"schema\", R.definer as \"rolname\", R.specific_name as \"name\"," + "group_concat(concat(P.parameter_name, \" \", P.data_type)) as \"arguments\", R.routine_definition as \"ddl\"\r\n" + "FROM information_schema.routines as R, information_schema.parameters as P\r\n" + @@ -469,50 +596,63 @@ public DBFunction getFunction(String schema, String name) { " and R.specific_name='" + name + "'\r\n" + "GROUP BY R.specific_name,1,2,5,P.ordinal_position ORDER BY P.ordinal_position"; - try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + try ( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ) { if(rs.next()) { - String owner = rs.getString("rolname"); + final String owner = rs.getString("rolname"); + final String sql = rs.getString("ddl"); - function = new DBFunction(name, schema, owner); - rowToProperties(rs, function.getOptions()); //String args = rs.getString("arguments"); //function.setArguments(args); + return new DBFunction(name, new StringProperties(rs), schema, owner, Collections.emptySet(), sql); + } else { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } } catch (Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); + final String msg = lang.getValue("errors", "adapter", "fnc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return function; } @Override public Map getTriggers(String schema) { - Map listTrigger = new HashMap(); - String query = "show triggers in " + schema; - - try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + final Map listTrigger = new HashMap(); + final String query = "show triggers in " + schema; + try ( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ) { while(rs.next()){ //TODO find real owner - String name = rs.getString(1); - DBTrigger trigger = new DBTrigger(name, schema, schema); - String ddlQuery = "show create trigger " + schema + "." + name; + final String name = rs.getString(1); + final String ddlQuery = "show create trigger " + schema + "." + name; - try(Statement stmtDdl = getConnection().createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery);){ - rsDdl.next(); - trigger.setSql(rsDdl.getString(3)); - rowToProperties(rs, trigger.getOptions()); + try( + Statement stmtDdl = getConnection().createStatement(); + ResultSet rsDdl = stmtDdl.executeQuery(ddlQuery); + ){ + if(!rsDdl.next()) throw new ExceptionDBGitRunTime("failed to get ddl resultset"); + + final String sql = rsDdl.getString(3); + final StringProperties options = new StringProperties(rs); + final DBTrigger trigger = new DBTrigger(name, options, schema, schema, Collections.emptySet(), sql); + listTrigger.put(name, trigger); } - listTrigger.put(name, trigger); } } catch(Exception e) { - throw new ExceptionDBGitRunTime(e); + final String msg = lang.getValue("errors", "adapter", "triggers").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listTrigger; @@ -520,255 +660,191 @@ public Map getTriggers(String schema) { @Override public DBTrigger getTrigger(String schema, String name) { + final String query = "show create trigger " + schema + "." + name; - DBTrigger trigger = null; - String query = "show create trigger " + schema + "." + name; - - try (Statement stmtDdl = getConnection().createStatement(); ResultSet rsDdl = stmtDdl.executeQuery(query);) { + try ( + Statement stmtDdl = getConnection().createStatement(); + ResultSet rsDdl = stmtDdl.executeQuery(query); + ) { - rsDdl.next(); + if(rsDdl.next()){ - //TODO find real owner - trigger = new DBTrigger(name, schema, schema); - trigger.getOptions().addChild("ddl", cleanString(rsDdl.getString(3))); + final StringProperties options = new StringProperties(rsDdl); + final String sql = rsDdl.getString("SQL Original Statement"); + return new DBTrigger(name, options, schema, schema, Collections.emptySet(), sql); + } else { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } } catch(Exception e) { throw new ExceptionDBGitRunTime(e); } - return trigger; } @Override public DBTableData getTableData(String schema, String nameTable) { - DBTableData data = new DBTableData(); - String tableName = schema + ".`" + nameTable + "`"; - String dataQuery = "select * from " + tableName; - try { - int maxRowsCount = DBGitConfig.getInstance().getInteger( + final int maxRowsCount = DBGitConfig.getInstance().getInteger( "core", "MAX_ROW_COUNT_FETCH", DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH) ); - - boolean toLimitFetch = DBGitConfig.getInstance().getBoolean( + final boolean toLimitFetch = DBGitConfig.getInstance().getBoolean( "core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true) ); - String query = - "select COALESCE(count(*), 0) kolvo" + - " from ( select 1 from " + tableName + " limit " + (maxRowsCount + 1) + " ) tbl"; - + final String tableName = schema + ".`" + nameTable + "`"; + final String dataQuery = "select * from " + tableName; + final String rowsCountQuery = + "select COALESCE(count(*), 0) kolvo " + + "from ( " + + " select 1 " + + " from " + tableName + " " + + " limit " + (maxRowsCount + 1) + " " + + ") tbl"; if (toLimitFetch) { - try (Statement st = getConnection().createStatement(); ResultSet rs = st.executeQuery(query);){ - rs.next(); - + try ( + Statement st = getConnection().createStatement(); + ResultSet rs = st.executeQuery(rowsCountQuery); + ){ + if(!rs.next()) throw new ExceptionDBGitRunTime("Could not execute rows count query"); if (rs.getInt("kolvo") > maxRowsCount) { - data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); - } else { - ResultSet dataResultSet = st.executeQuery(dataQuery); - data.setResultSet(dataResultSet); + return new DBTableData(DBTableData.ERROR_LIMIT_ROWS); } - - } } - + return new DBTableData(getConnection(), dataQuery); + } catch(Exception e) { - throw new ExceptionDBGitRunTime(e); + final String msg = DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return data; } @Override - public Map getUsers() { - Map users = new HashMap(); - String query = "select User, authentication_string from mysql.user"; + public DBTableData getTableDataPortion(String schema, String nameTable, int portionIndex, int tryNumber) { + final int portionSize = DBGitConfig.getInstance().getInteger("core", "PORTION_SIZE", DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000)); + final int beginRowNum = 1 + portionSize * portionIndex; + final int endRowNum = portionSize + portionSize * portionIndex; + + final String dataQuery = + "SELECT * " + "\n" + + "FROM (" + "\n" + + " SELECT " + "\n" + + " f.*, " + "\n" + + " ROW_NUMBER() OVER (" + "\n" + + " ORDER BY (" + "\n" + + " select group_concat(column_name separator ', ') " + "\n" + + " from information_schema.columns " + "\n" + + " where table_schema='" + schema + "' " + "\n" + + " and table_name='" + nameTable + "' " + "\n" + + " and upper(column_key)='PRI'" + "\n" + + " )" + "\n" + + " ) DBGIT_ROW_NUM " + "\n" + + " FROM " + schema + "." + nameTable + " f" + "\n" + + ") s \n" + + "WHERE DBGIT_ROW_NUM BETWEEN " + beginRowNum + " AND " + endRowNum; - try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ + try { - while(rs.next()) { - String name = rs.getString(1); - String password = rs.getString(2); - StringProperties options = new StringProperties(); - options.addChild("password", password); - DBUser user = new DBUser(name, options); - users.put(name, user); - } + return new DBTableData(getConnection(), dataQuery); } catch(Exception e) { - logger.error(e.getMessage()); - throw new ExceptionDBGitRunTime(e.getMessage()); - } - - return users; - } - @Override - public Map getRoles() { - Map roles = new HashMap(); - return roles; - } + final int maxTriesCount = DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000)); + final int tryDelay = DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000)); - @Override - public boolean userHasRightsToGetDdlOfOtherUsers() { - return true; - } + ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); + ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); + logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - @Override - public IFactoryDBBackupAdapter getBackupAdapterFactory() { - return backupFactory; - } + if (tryNumber <= maxTriesCount) { - @Override - public DbType getDbType() { - return DbType.MYSQL; - } + final String waitMessage = DBGitLang.getInstance() + .getValue("errors", "dataTable", "wait") + .withParams(String.valueOf(tryDelay)); - @Override - public String getDbVersion() { - try { - PreparedStatement stmt = getConnection().prepareStatement("SELECT version()"); - ResultSet resultSet = stmt.executeQuery(); - resultSet.next(); - - String result = resultSet.getString(1); - resultSet.close(); - stmt.close(); - - return result; - } catch (SQLException e) { - return ""; - } - } + final String tryAgainMessage = DBGitLang.getInstance() + .getValue("errors", "dataTable", "tryAgain") + .withParams(String.valueOf(tryNumber)); - @Override - public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit { - String query = - "select count(*) cnt from information_schema.schemata where upper(schema_name) = '" + - schemaName.toUpperCase() + "'"; - - try (Statement st = connect.createStatement(); ResultSet rs = st.executeQuery(query);) { + ConsoleWriter.println(waitMessage, messageLevel); + try { TimeUnit.SECONDS.sleep(tryDelay); } catch (InterruptedException e1) { + throw new ExceptionDBGitRunTime(e1.getMessage()); + } - rs.next(); - if (rs.getInt("cnt") == 0) - try(StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql());) { + ConsoleWriter.println(tryAgainMessage, messageLevel); + return getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); - stLog.execute("create schema " + schemaName); + } else { + final String msg = DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - } catch (SQLException e) { - throw new ExceptionDBGit(lang.getValue("errors", "adapter", "createSchema") + ": " + e.getLocalizedMessage()); } } @Override - public void createRoleIfNeed(String roleName) throws ExceptionDBGit { - // TODO Auto-generated method stub + public Map getUsers() { + final Map users = new HashMap(); + final String query = "select User, authentication_string from mysql.user"; - } + try ( + Statement stmt = getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(query); + ) { - protected String getFieldType(ResultSet rs) { - try { - StringBuilder type = new StringBuilder(); - type.append(rs.getString("data_type")); - - BigDecimal max_length = rs.getBigDecimal("character_maximum_length"); - if (!rs.wasNull()) { - type.append("(" + max_length + ")"); - } - if (rs.getString("is_nullable").equals("NO")){ - type.append(" NOT NULL"); + while(rs.next()) { + final String name = rs.getString(1); + final String password = rs.getString(2); + final StringProperties options = new StringProperties(); + options.addChild("password", password); + + final DBUser user = new DBUser(name, options); + users.put(name, user); } - - return type.toString(); - } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); - } - } - @Override - public String getDefaultScheme() throws ExceptionDBGit { - try { - return getConnection().getCatalog(); - } catch (SQLException e) { - throw new ExceptionDBGit(lang.getValue("errors", "adapter", "getSchema") + ": " + e.getLocalizedMessage()); + } catch(Exception e) { + throw new ExceptionDBGitRunTime(e); } - } - @Override - public IFactoryDBConvertAdapter getConvertAdapterFactory() { - return convertFactory; + return users; } @Override - public boolean isReservedWord(String word) { - return reservedWords.contains(word.toUpperCase()); - } + public Map getRoles() { return Collections.emptyMap(); } - @Override - public DBTableData getTableDataPortion(String schema, String nameTable, int portionIndex, int tryNumber) { - DBTableData data = new DBTableData(); + protected String getFieldType(ResultSet rs) { try { - int portionSize = DBGitConfig.getInstance().getInteger("core", "PORTION_SIZE", DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000)); - - int begin = 1 + portionSize * portionIndex; - int end = portionSize + portionSize * portionIndex; - - Statement st = getConnection().createStatement(); - ResultSet rs = st.executeQuery("SELECT * FROM \r\n" + - "(SELECT f.*, ROW_NUMBER() OVER (ORDER BY (select group_concat(column_name separator ', ') from information_schema.columns where \r\n" + - "table_schema='" + schema + "' and table_name='" + nameTable + "' and upper(column_key)='PRI')) DBGIT_ROW_NUM FROM " + schema + "." + nameTable + " f) s \r\n" + - "WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end); - data.setResultSet(rs); - return data; - } catch(Exception e) { - - ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); - ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); - logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); + final StringBuilder type = new StringBuilder(); - try { - if (tryNumber <= DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000))) { - try { - TimeUnit.SECONDS.sleep(DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000))); - } catch (InterruptedException e1) { - throw new ExceptionDBGitRunTime(e1.getMessage()); - } - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("errors", "dataTable", "loadPortionError") - .withParams(String.valueOf(tryNumber)) - , messageLevel - ); - getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); - } - } catch (Exception e1) { - // TODO Auto-generated catch block - e1.printStackTrace(); + if (!rs.wasNull()) { + final String typePart = rs.getString("data_type"); + final String lengthPart = "(" + rs.getBigDecimal("character_maximum_length") + ")"; + final String nullablePart = rs.getString("is_nullable").equals("NO") ? " NOT NULL" : ""; + type.append( typePart ); + type.append( lengthPart ); + type.append( nullablePart ); } - try { - getConnection().rollback(); - } catch (Exception e2) { - logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); - } - throw new ExceptionDBGitRunTime(e.getMessage()); + return type.toString(); + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } - - private NamedParameterPreparedStatement getParamStatement(String query, Connection connect) throws SQLException { - return NamedParameterPreparedStatement.createNamedParameterPreparedStatement(connect, query); + private NamedParameterPreparedStatement getParamStatement(String query) throws SQLException { + return NamedParameterPreparedStatement.createNamedParameterPreparedStatement(getConnection(), query); } static { - reservedWords = new HashSet<>(); reservedWords.add("ACCESSIBLE"); reservedWords.add("ACCOUNT"); reservedWords.add("ACTION"); diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java index 9b2befe..bf1da5e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBRestoreTableDataMySql.java @@ -54,7 +54,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { currentTableData.getmapRows().clear(); if (getAdapter().getTable(schema, currentTableData.getTable().getName()) != null) { currentTableData.setDataTable(getAdapter().getTableData(schema, currentTableData.getTable().getName())); - ResultSet rs = currentTableData.getDataTable().getResultSet(); + ResultSet rs = currentTableData.getDataTable().resultSet(); TreeMapRowData mapRows = new TreeMapRowData(); MetaTable metaTable = new MetaTable(currentTableData.getTable()); metaTable.loadFromDB(currentTableData.getTable()); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java index c908fad..c813cf5 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java @@ -5,12 +5,9 @@ import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; +import java.util.*; import java.util.Map.Entry; import java.util.concurrent.TimeUnit; -import java.util.Set; import org.apache.commons.lang3.exception.ExceptionUtils; import ru.fusionsoft.dbgit.adapters.DBAdapter; @@ -19,10 +16,7 @@ import ru.fusionsoft.dbgit.adapters.IFactoryDBAdapterRestoteMetaData; import ru.fusionsoft.dbgit.adapters.IFactoryDBBackupAdapter; import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; -import ru.fusionsoft.dbgit.core.DBGitConfig; -import ru.fusionsoft.dbgit.core.DBGitLang; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; +import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.data_table.BooleanData; @@ -50,24 +44,33 @@ import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMapMetaObject; import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.TreeMapMetaObject; import ru.fusionsoft.dbgit.oracle.FactoryDBAdapterRestoreOracle; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; import org.slf4j.Logger; +import ru.fusionsoft.dbgit.utils.StringProperties; public class DBAdapterOracle extends DBAdapter { - private Logger logger = LoggerUtil.getLogger(this.getClass()); - private FactoryDBAdapterRestoreOracle restoreFactory = new FactoryDBAdapterRestoreOracle(); - private FactoryDbConvertAdapterOracle convertFactory = new FactoryDbConvertAdapterOracle(); - private FactoryDBBackupAdapterOracle backupFactory = new FactoryDBBackupAdapterOracle(); + final private Logger logger = LoggerUtil.getLogger(this.getClass()); + final private FactoryDBAdapterRestoreOracle restoreFactory = new FactoryDBAdapterRestoreOracle(); + final private FactoryDbConvertAdapterOracle convertFactory = new FactoryDbConvertAdapterOracle(); + final private FactoryDBBackupAdapterOracle backupFactory = new FactoryDBBackupAdapterOracle(); + final private static Set reservedWords = new HashSet<>(); @Override public IFactoryDBAdapterRestoteMetaData getFactoryRestore() { return restoreFactory; } + @Override + public IFactoryDBBackupAdapter getBackupAdapterFactory() { return backupFactory; } + @Override + public IFactoryDBConvertAdapter getConvertAdapterFactory() { + return convertFactory; + } @Override public void startUpdateDB() { @@ -80,33 +83,131 @@ public void endUpdateDB() { // TODO Auto-generated method stub } - + + @Override + public boolean userHasRightsToGetDdlOfOtherUsers() { + try { + String userName = getConnection().getSchema(); + + if (userName.equalsIgnoreCase("SYS")) + return true; + + PreparedStatement stmt = getConnection().prepareStatement + ("SELECT count(1) cnt FROM DBA_ROLE_PRIVS WHERE GRANTEE = ? and GRANTED_ROLE = 'SELECT_CATALOG_ROLE'"); + stmt.setString(1, userName); + ResultSet resultSet = stmt.executeQuery(); + resultSet.next(); + + if (resultSet.getInt(1) == 0) { + return false; + } else { + return true; + } + } catch (SQLException e) { + logger.error(e.getMessage()); + return false; + } + } + + @Override + public DbType getDbType() { + return DbType.ORACLE; + } + @Override + public String getDbVersion() { + final String query = "SELECT version FROM V$INSTANCE"; + try ( + PreparedStatement stmt = getConnection().prepareStatement(query); + ResultSet resultSet = stmt.executeQuery(); + ) { + + if(!resultSet.next()) throw new ExceptionDBGitRunTime("get db version resultset is empty"); + final String result = resultSet.getString("version"); + + return result; + + } catch (SQLException e) { + throw new ExceptionDBGitRunTime(e); + } + } + @Override + public String getDefaultScheme() throws ExceptionDBGit { + try { + return getConnection().getSchema(); + } catch (SQLException e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "getSchema"); + throw new ExceptionDBGit(msg, e); + } + } + + @Override + public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit { + final String userCountQuery = "select count(*) cnt from all_users where USERNAME = '" + schemaName.toUpperCase() + "'"; + try ( + Statement st = connect.createStatement(); + ResultSet rs = st.executeQuery(userCountQuery); + ) { + + if(!rs.next()) throw new ExceptionDBGitRunTime("get schema count empty resultset"); + if (rs.getInt("cnt") == 0) { + try(StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql());){ + + final String configureUserQuery = "ALTER USER \"" + schemaName.toUpperCase() + "\" QUOTA UNLIMITED ON SYSTEM"; + final String createUserQuery = + "create USER \"" + schemaName.toUpperCase() + "\"\r\n" + + "IDENTIFIED BY \"" + schemaName.toUpperCase() + "\"\r\n" + + "DEFAULT TABLESPACE \"SYSTEM\"\r\n" + + "TEMPORARY TABLESPACE \"TEMP\"\r\n" + + "ACCOUNT UNLOCK"; + + stLog.execute(createUserQuery); + stLog.execute(configureUserQuery); + } + } + + } catch (SQLException e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "createSchema"); + throw new ExceptionDBGit(msg, e); + } + + } + @Override + public void createRoleIfNeed(String roleName) throws ExceptionDBGit { + //TODO implement + } + + @Override + public boolean isReservedWord(String word) { + return reservedWords.contains(word.toUpperCase()); + } + @Override public IMapMetaObject loadCustomMetaObjects() { - return null; + return new TreeMapMetaObject(Collections.emptyList()); } @Override public Map getSchemes() { - Map listScheme = new HashMap(); - String query = + final Map listScheme = new HashMap(); + final String query = "SELECT DISTINCT OWNER\n" + "FROM DBA_OBJECTS WHERE OWNER != 'PUBLIC' AND OWNER != 'SYSTEM'\n" + "AND OWNER != 'SYS' AND OWNER != 'APPQOSSYS' AND OWNER != 'OUTLN' \n" + "AND OWNER != 'DIP' AND OWNER != 'DBSNMP' AND OWNER != 'ORACLE_OCM'\n" + "ORDER BY OWNER"; + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ while(rs.next()){ - String name = rs.getString("OWNER"); - DBSchema scheme = new DBSchema(name); - rowToProperties(rs, scheme.getOptions()); - listScheme.put(name, scheme); + final String name = rs.getString("OWNER"); + final DBSchema scheme = new DBSchema(name, new StringProperties(rs)); + + listScheme.put(name, scheme); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "schemes").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "schemes").toString(), e); + final String msg = lang.getValue("errors", "adapter", "schemes").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listScheme; @@ -114,9 +215,8 @@ public Map getSchemes() { @Override public Map getTableSpaces() { - - Map listTableSpace = new HashMap(); - String query = + final Map listTableSpace = new HashMap(); + final String query = "SELECT owner,\n" + " segment_name,\n" + " partition_name,\n" + @@ -130,15 +230,14 @@ public Map getTableSpaces() { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ while(rs.next()){ - String name = rs.getString("segment_name"); - DBTableSpace dbTableSpace = new DBTableSpace(name); - rowToProperties(rs, dbTableSpace.getOptions()); + final String name = rs.getString("segment_name"); + final DBTableSpace dbTableSpace = new DBTableSpace(name, new StringProperties(rs)); listTableSpace.put(name, dbTableSpace); } } catch(Exception e) { - logger.error(e.getMessage()); - throw new ExceptionDBGitRunTime(e); + final String msg = lang.getValue("errors", "adapter", "tablespace").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listTableSpace; @@ -146,7 +245,7 @@ public Map getTableSpaces() { @Override public Map getSequences(String schema) { - Map listSequence = new HashMap(); + final Map listSequence = new HashMap(); //variant 1 from DBA_OBJECTS /*String query = @@ -155,7 +254,7 @@ public Map getSequences(String schema) { "FROM DBA_OBJECTS O WHERE OBJECT_TYPE = 'SEQUENCE' AND OWNER = :schema";*/ //variant 2 from DBA_SEQUENCES - String query = + final String query = "SELECT S.SEQUENCE_NAME, (SELECT dbms_metadata.get_ddl('SEQUENCE', S.SEQUENCE_NAME, S.SEQUENCE_OWNER) from dual) AS DDL,\n" + "order_flag, increment_by, last_number, min_value, max_value, cache_size \n" + "FROM DBA_SEQUENCES S WHERE S.SEQUENCE_OWNER = '" + schema + "'"; @@ -163,16 +262,17 @@ public Map getSequences(String schema) { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ - String nameSeq = rs.getString("SEQUENCE_NAME"); //TODO find real sequence value - DBSequence sequence = new DBSequence(nameSeq, schema, 0L); - rowToProperties(rs, sequence.getOptions()); + final long valueSeq = 0L; + final String nameSeq = rs.getString("SEQUENCE_NAME"); + final String ownerSeq = ""; + final DBSequence sequence = new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); listSequence.put(nameSeq, sequence); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "sequences").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "sequences").toString(), e); + final String msg = lang.getValue("errors", "adapter", "seq").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listSequence; @@ -180,51 +280,55 @@ public Map getSequences(String schema) { @Override public DBSequence getSequence(String schema, String name) { - DBSequence sequence = null; - - String query = + final String query = "SELECT S.SEQUENCE_NAME, (SELECT dbms_metadata.get_ddl('SEQUENCE', S.SEQUENCE_NAME, S.SEQUENCE_OWNER) from dual) AS DDL, \n" + "order_flag, increment_by, last_number, min_value, max_value, cache_size \n" + "FROM DBA_SEQUENCES S WHERE S.SEQUENCE_OWNER = '" + schema + "' AND S.SEQUENCE_NAME = '" + name + "'"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - - while (rs.next()) { - String nameSeq = rs.getString("SEQUENCE_NAME"); - + if (rs.next()) { //TODO find real sequence value - sequence = new DBSequence(nameSeq, schema, 0L); - rowToProperties(rs, sequence.getOptions()); + final long valueSeq = 0L; + final String nameSeq = rs.getString("SEQUENCE_NAME"); + final String ownerSeq = ""; + return new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); + } else { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "sequences").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "sequences").toString(), e); + final String msg = lang.getValue("errors", "adapter", "sequence").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - - return sequence; } @Override public Map getTables(String schema) { - Map listTable = new HashMap(); - - String query = + final Map listTable = new HashMap(); + final String query = "SELECT T.TABLE_NAME, T.OWNER, (SELECT dbms_metadata.get_ddl('TABLE', T.TABLE_NAME, T.OWNER) from dual) AS DDL\n" + "FROM DBA_TABLES T WHERE upper(OWNER) = upper('" + schema + "') and nested = 'NO' and (iot_type <> 'IOT_OVERFLOW' or iot_type is null)"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - while(rs.next()){ - String nameTable = rs.getString("TABLE_NAME"); - DBTable table = new DBTable(nameTable, schema); - rowToProperties(rs, table.getOptions()); + //TODO retrieve table comment + //TODO retrieve table owner + final String nameTable = rs.getString("TABLE_NAME"); + final String ownerTable = ""; + final String commentTable = ""; + final StringProperties options = new StringProperties(rs); + final Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); + + final DBTable table = new DBTable(nameTable, options, schema, ownerTable, dependencies, commentTable); listTable.put(nameTable, table); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + final String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listTable; @@ -232,51 +336,77 @@ public Map getTables(String schema) { @Override public DBTable getTable(String schema, String name) { - DBTable table = null; - String query = + final String query = "SELECT T.TABLE_NAME, T.OWNER, (SELECT dbms_metadata.get_ddl('TABLE', T.TABLE_NAME, T.OWNER) from dual) AS DDL\n" + "FROM DBA_TABLES T WHERE upper(T.OWNER) = upper('" + schema + "') AND upper(T.TABLE_NAME) = upper('" + name + "')"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - while(rs.next()) { - String nameTable = rs.getString("TABLE_NAME"); - table = new DBTable(nameTable, schema); - rowToProperties(rs, table.getOptions()); + if (rs.next()) { + //TODO retrieve table comment + //TODO retrieve table owner + final String nameTable = rs.getString("TABLE_NAME"); + final String ownerTable = ""; + final String commentTable = ""; + final StringProperties options = new StringProperties(rs); + final Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); + + return new DBTable(nameTable, options, schema, ownerTable, dependencies, commentTable); + } else { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + final String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return table; } @Override public Map getTableFields(String schema, String nameTable) { - Map listField = new HashMap(); + final Map listField = new HashMap(); - String pkNameQuery = + final String pkNameQuery = "SELECT column_name FROM all_constraints cons, all_cons_columns cols\n"+ "WHERE upper(cols.table_name) = upper('" + nameTable + "')\n"+ "AND cons.constraint_type = 'P'\n" + "AND cons.constraint_name = cols.constraint_name\n" + "AND cons.owner = cols.owner"; - String query = - "SELECT case \r\n" + - " when lower(data_type) in ('number', 'numeric', 'dec', 'decimal', 'pls_integer') then 'number'\r\n" + - " when lower(data_type) in ('varchar2', 'varchar', 'char', 'nchar', 'nvarchar2') then 'string'\r\n" + - " when substr(lower(data_type), 1, instr(data_type, '(') - 1) in ('date', 'timestamp') then 'date'\r\n" + - " when lower(data_type) in ('date', 'timestamp') then 'date'\r\n" + - " when lower(data_type) in ('clob') then 'text'\r\n" + - " when lower(data_type) in ('blob') then 'binary'" + - " else 'native'\r\n" + - " end type, " + - " case when lower(data_type) in ('char', 'nchar') then 1 else 0 end fixed, " + - " ROWNUM AS NUM, TC.* FROM DBA_TAB_COLS TC \n" + + final String query = + "SELECT " + + " case \r\n" + + " when lower(data_type) in ('number', 'numeric', 'dec', 'decimal', 'pls_integer') then 'number'\r\n" + + " when lower(data_type) in ('varchar2', 'varchar', 'char', 'nchar', 'nvarchar2') then 'string'\r\n" + + " when substr(lower(data_type), 1, instr(data_type, '(') - 1) in ('date', 'timestamp') then 'date'\r\n" + + " when lower(data_type) in ('date', 'timestamp') then 'date'\r\n" + + " when lower(data_type) in ('clob') then 'text'\r\n" + + " when lower(data_type) in ('blob') then 'binary'" + + " else 'native'\r\n" + + " end type, " + + " case " + + " when lower(data_type) in ('char', 'nchar') then 1 else 0 " + + " end fixed, " + + " ROWNUM AS NUM, " + + " TC.* \n" + + " DTC.COMMENTS \n" + + "FROM DBA_TAB_COLS TC \n" + + "LEFT OUTER JOIN dba_tables T " + + " ON T.TABLE_NAME = TC.TABLE_NAME " + + " AND T.COLUMN_NAME = TC.COLUMN_NAME \n" + + " AND T.OWNER = TC.OWNER \n" + + //So I checked the documentation it turns out Oracle 10g added a column called DROPPED to the USER_/ALL_/DBA_TABLES views. + ( (getDbVersionNumber() >= 10) ? + " AND T.DROPPED = 'NO' \n" : "" ) + + "LEFT OUTER JOIN dba_tab_comment TCOM " + + " ON TCOM.OWNER = T.OWNER " + + " AND TCOM.TABLE_NAME = T.TABLE_NAME " + + " AND TCOM.COLUMN_NAME = TC.COLUMN_NAME " + "WHERE lower(table_name) = lower('" + nameTable + "') AND lower(OWNER) = lower('" + schema + "') ORDER BY column_id"; try ( @@ -285,63 +415,68 @@ public Map getTableFields(String schema, String nameTable) ResultSet fieldsRs = stmt.executeQuery(query); ){ - String pkColumnName = ""; - while (pkRs.next()) { pkColumnName = pkRs.getString("COLUMN_NAME").toLowerCase(); } - + final Set pkColumnNames = new HashSet<>(); + while (pkRs.next()) { pkColumnNames.add(pkRs.getString("COLUMN_NAME").toLowerCase()); } while(fieldsRs.next()){ + //TODO make restore 'description', 'column default' + final String columnName = fieldsRs.getString("COLUMN_NAME").toLowerCase(); + final String columnDesc = fieldsRs.getString("COMMENTS"); + final Long columnDefault = fieldsRs.getLong("DATA_DEFAULT"); + final String typeSQL = getFieldType(fieldsRs); + final FieldType typeUniversal = FieldType.fromString(fieldsRs.getString("TYPE").toUpperCase()); + final int order = fieldsRs.getInt("column_id"); + final boolean isPrimaryKey = pkColumnNames.contains(columnName); + final boolean isNullable = !typeSQL.toLowerCase().contains("not null"); + final boolean fixed = fieldsRs.getBoolean("fixed"); + final int dataLength = fieldsRs.getInt("DATA_LENGTH"); + final int dataScale = fieldsRs.getInt("DATA_SCALE"); + final int dataPrecision = fieldsRs.getInt("DATA_PRECISION"); + + + final DBTableField field = new DBTableField( + columnName, + columnDesc != null ? columnDesc : "", + isPrimaryKey, + isNullable, + typeSQL, typeUniversal, order, + columnDefault != null ? String.valueOf(columnDefault) : "", + dataLength, dataScale, dataPrecision, fixed + ); - DBTableField field = new DBTableField(); - - field.setName(fieldsRs.getString("COLUMN_NAME").toLowerCase()); - if (fieldsRs.getString("COLUMN_NAME").toLowerCase().equals(pkColumnName)) { - field.setIsPrimaryKey(true); - } - String typeSQL = getFieldType(fieldsRs); - field.setTypeSQL(typeSQL); - field.setIsNullable( !typeSQL.toLowerCase().contains("not null")); - field.setTypeUniversal(FieldType.fromString(fieldsRs.getString("TYPE").toUpperCase())); - field.setLength(fieldsRs.getInt("DATA_LENGTH")); - field.setScale(fieldsRs.getInt("DATA_SCALE")); - field.setPrecision(fieldsRs.getInt("DATA_PRECISION")); - field.setFixed(fieldsRs.getBoolean("fixed")); - field.setOrder(fieldsRs.getInt("column_id")); listField.put(field.getName(), field); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + final String msg = lang.getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listField; } - protected String getFieldType(ResultSet rs) { - try { - StringBuilder type = new StringBuilder(); - type.append(rs.getString("DATA_TYPE")); - - Integer max_length = rs.getInt("CHAR_LENGTH"); - if (!rs.wasNull() && !rs.getString("DATA_TYPE").contains("(")) { - type.append("("+max_length.toString()+")"); - } - - if (rs.getString("NULLABLE").equals("N")){ - type.append(" NOT NULL"); - } - - return type.toString(); - } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); - } + protected String getFieldType(ResultSet rs) throws SQLException { + final StringBuilder type = new StringBuilder(); + final Integer max_length = rs.getInt("CHAR_LENGTH"); + final String data_type = rs.getString("DATA_TYPE"); + + type.append(data_type); + + if (!rs.wasNull() && !data_type.contains("(")) { + type.append("("+max_length.toString()+")"); + } + + if (rs.getString("NULLABLE").equals("N")){ + type.append(" NOT NULL"); + } + + return type.toString(); } @Override public Map getIndexes(String schema, String nameTable) { - Map indexes = new HashMap<>(); - String query = + final Map indexes = new HashMap<>(); + final String query = "SELECT ind.index_name, (select dbms_metadata.get_ddl('INDEX', ind.INDEX_NAME, owner) AS DDL from dual) AS DDL\n" + "FROM all_indexes ind\n" + "WHERE upper(table_name) = upper('" + nameTable + "') AND upper(owner) = upper('" + schema + "')"; @@ -350,15 +485,15 @@ public Map getIndexes(String schema, String nameTable) { while(rs.next()){ //TODO find real owner - String name = rs.getString("INDEX_NAME"); - DBIndex index = new DBIndex(name, schema, schema); - rowToProperties(rs, index.getOptions()); + final String name = rs.getString("INDEX_NAME"); + final String sql = rs.getString("DDL"); + final DBIndex index = new DBIndex(name, new StringProperties(rs), schema, schema, Collections.emptySet(), sql); indexes.put(index.getName(), index); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "indexes").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "indexes").toString(), e); + final String msg = lang.getValue("errors", "adapter", "indexes").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return indexes; @@ -366,9 +501,9 @@ public Map getIndexes(String schema, String nameTable) { @Override public Map getConstraints(String schema, String nameTable) { - Map constraints = new HashMap<>(); + final Map constraints = new HashMap<>(); - String query = + final String query = "SELECT cons.constraint_type, cons.CONSTRAINT_NAME, (select dbms_metadata.get_ddl('CONSTRAINT', cons.constraint_name, owner) AS DDL from dual) AS DDL\n" + "FROM all_constraints cons\n" + "WHERE upper(owner) = upper('" + schema + "') and upper(table_name) = upper('" + nameTable + "') and constraint_name not like 'SYS%' and cons.constraint_type = 'P'"; @@ -376,19 +511,21 @@ public Map getConstraints(String schema, String nameTable) try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ - String name = rs.getString("CONSTRAINT_NAME"); - //This is DDL? - String type = rs.getString("CONSTRAINT_TYPE"); //TODO find real owner - DBConstraint con = new DBConstraint(name, schema, schema, type); - rowToProperties(rs, con.getOptions()); + final String name = rs.getString("CONSTRAINT_NAME"); + final String sql = rs.getString("DDL"); + final String type = rs.getString("CONSTRAINT_TYPE"); + final String owner = schema; + final StringProperties options = new StringProperties(rs); + + final DBConstraint con = new DBConstraint(name, options, schema, owner, Collections.emptySet(), sql, type); constraints.put(con.getName(), con); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "constraints").toString()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "constraints").toString(), e); + final String msg = lang.getValue("errors", "adapter", "constraints").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return constraints; @@ -396,26 +533,28 @@ public Map getConstraints(String schema, String nameTable) @Override public Map getViews(String schema) { - Map listView = new HashMap(); - - String query = + final Map listView = new HashMap(); + final String query = "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('VIEW', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'VIEW'"; + "FROM all_objects f " + + "WHERE f.owner = '" + schema + "' and f.object_type = 'VIEW'"; + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ - String name = rs.getString("OBJECT_NAME"); - String owner = rs.getString("OWNER"); - - DBView view = new DBView(name, schema, owner); - rowToProperties(rs, view.getOptions()); - listView.put(rs.getString("OBJECT_NAME"), view); - + final String name = rs.getString("OBJECT_NAME"); + final String owner = rs.getString("OWNER"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); + final Set dependencies = Collections.emptySet(); + + final DBView view = new DBView(name, options, schema, owner, dependencies, sql); + listView.put(name, view); } } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views") + ": " + e.getMessage(), e); + final DBGitLang msg = lang.getValue("errors", "adapter", "views"); + throw new ExceptionDBGitRunTime(msg, e); } return listView; @@ -423,33 +562,31 @@ public Map getViews(String schema) { @Override public DBView getView(String schema, String name) { - DBView view = null; - String query = + final String query = "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('VIEW', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'VIEW' and f.object_name = '" + name + "'"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query); ){ - while (rs.next()) { - String owner = rs.getString("OWNER"); + if (!rs.next()) throw new ExceptionDBGitObjectNotFound("view is not found in db"); - view = new DBView(name, schema, owner); - rowToProperties(rs, view.getOptions()); - } + final String owner = rs.getString("owner"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); + return new DBView(name, options, schema, owner, Collections.emptySet(), sql); } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "views").toString() + ": "+ e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views").toString(), e); + final String msg = lang.getValue("errors", "adapter", "views").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return view; } public Map getTriggers(String schema) { - Map listTrigger = new HashMap(); - String query = + final Map listTrigger = new HashMap(); + final String query = "SELECT tr.owner, tr.trigger_name, tr.trigger_type, tr.table_name," + " (select dbms_metadata.get_ddl('TRIGGER', tr.trigger_name, tr.owner) AS DDL from dual) AS DDL\n" + "FROM all_triggers tr\n" + @@ -460,73 +597,73 @@ public Map getTriggers(String schema) { while(rs.next()){ //TODO find real owner //what means owner? oracle/postgres or owner like database user/schema - String owner = "oracle"; - String name = rs.getString("TRIGGER_NAME"); - String sql = rs.getString("DDL"); + final String owner = rs.getString("owner"); + final String name = rs.getString("TRIGGER_NAME"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); - DBTrigger trigger = new DBTrigger(name, schema, owner); - trigger.setSql(sql); - rowToProperties(rs, trigger.getOptions()); + final DBTrigger trigger = new DBTrigger(name, options, schema, owner, Collections.emptySet(), sql); listTrigger.put(name, trigger); } } catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); + final String msg = lang.getValue("errors", "adapter", "triggers").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listTrigger; } public DBTrigger getTrigger(String schema, String name) { - DBTrigger trigger = null; - String query = + final String query = "SELECT tr.owner, tr.trigger_name, tr.trigger_type, tr.table_name, (select dbms_metadata.get_ddl('TRIGGER', tr.trigger_name, tr.owner) AS DDL from dual) AS DDL\n" + "FROM all_triggers tr\n" + "WHERE owner = '" + schema + "' and trigger_name = '" + name + "'"; try (Statement stmt = connect.createStatement(); ResultSet rs = stmt.executeQuery(query);) { - while(rs.next()){ + if(!rs.next()) throw new ExceptionDBGitObjectNotFound("trigger is not found in database"); - //TODO find real owner - //what means owner? oracle/postgres or owner like database user/schema - String owner = "oracle"; + final String owner = rs.getString("owner"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); - trigger = new DBTrigger(name, schema, owner); - rowToProperties(rs, trigger.getOptions()); - } + return new DBTrigger(name, options, schema, owner, Collections.emptySet(), sql); } catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); + final String msg = lang.getValue("errors", "adapter", "triggers").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return trigger; } @Override public Map getPackages(String schema) { - Map listPackage = new HashMap(); - - String query = + final Map listPackage = new HashMap(); + final String query = "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('PACKAGE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PACKAGE'"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query); ){ while(rs.next()){ - String name = rs.getString("OBJECT_NAME"); - String owner = rs.getString("OWNER"); - DBPackage pack = new DBPackage(name, schema, owner); - rowToProperties(rs,pack.getOptions()); + final String name = rs.getString("OBJECT_NAME"); + final String owner = rs.getString("OWNER"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); + //String args = rs.getString("arguments"); //pack.setArguments(args); + + final DBPackage pack = new DBPackage(name, options, schema, owner, Collections.emptySet(), sql); listPackage.put(name, pack); } } catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "pkg").toString(), e); + final String msg = lang.getValue("errors", "adapter", "pkg").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listPackage; @@ -534,53 +671,55 @@ public Map getPackages(String schema) { @Override public DBPackage getPackage(String schema, String name) { - DBPackage pack = null; - - String query = + final String query = "SELECT f.owner, f.object_name, (select dbms_metadata.get_ddl('PACKAGE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PACKAGE' and f.object_name = '" + name + "'"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - while (rs.next()) { - String owner = rs.getString("OWNER"); - pack = new DBPackage(name, schema, owner); - //String args = rs.getString("arguments"); - //pack.setArguments(args); - rowToProperties(rs,pack.getOptions()); - } + if (!rs.next()) throw new ExceptionDBGitObjectNotFound("package is not found in db"); + + final String owner = rs.getString("OWNER"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); + + //String args = rs.getString("arguments"); + //pack.setArguments(args); + return new DBPackage(name, options, schema, owner, Collections.emptySet(), sql); } catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views").toString(), e); + final String msg = lang.getValue("errors", "adapter", "views").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return pack; } @Override public Map getProcedures(String schema) { - Map listProcedure = new HashMap(); - - String query = + final Map listProcedure = new HashMap(); + final String query = "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('PROCEDURE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + - "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PROCEDURE'"; + "FROM all_objects f WHERE f.owner = '" + schema + "' " + + "AND f.object_type = 'PROCEDURE'"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ - String name = rs.getString("OBJECT_NAME"); - String owner = rs.getString("OWNER"); + final String name = rs.getString("OBJECT_NAME"); + final String owner = rs.getString("OWNER"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); - DBProcedure proc = new DBProcedure(name, schema, owner); - rowToProperties(rs,proc.getOptions()); //String args = rs.getString("arguments"); //proc.setArguments(args); + final DBProcedure proc = new DBProcedure(name, options, schema, owner, Collections.emptySet(), sql); listProcedure.put(name, proc); } } catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); + final String msg = lang.getValue("errors", "adapter", "prc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listProcedure; @@ -588,53 +727,54 @@ public Map getProcedures(String schema) { @Override public DBProcedure getProcedure(String schema, String name) { - DBProcedure proc = null; - String query = + final String query = "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('PROCEDURE', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'PROCEDURE' and f.object_name = '" + name + "'"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - while (rs.next()) { - String objName = rs.getString("OBJECT_NAME"); - String owner = rs.getString("OWNER"); - proc = new DBProcedure(objName, schema, owner); - //String args = rs.getString("arguments"); - //proc.setArguments(args); - rowToProperties(rs,proc.getOptions()); - } + if (!rs.next()) throw new ExceptionDBGitObjectNotFound("procedure is not found in database"); + + final String objName = rs.getString("OBJECT_NAME"); + final String owner = rs.getString("OWNER"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); + + return new DBProcedure(name, options, schema, owner, Collections.emptySet(), sql); } catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "prc").toString(), e); + final String msg = lang.getValue("errors", "adapter", "prc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return proc; } @Override public Map getFunctions(String schema) { - Map listFunction = new HashMap(); - String query = + final Map listFunction = new HashMap(); + final String query = "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS \r\n" + "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('FUNCTION', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + "FROM all_objects f WHERE f.owner = '" + schema + "' and f.object_type = 'FUNCTION'"; try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ - String name = rs.getString("OBJECT_NAME"); - String sql = rs.getString("DDL"); - String owner = rs.getString("OWNER"); - DBFunction func = new DBFunction(name, schema, owner); - rowToProperties(rs,func.getOptions()); + final String name = rs.getString("OBJECT_NAME"); + final String sql = rs.getString("DDL"); + final String owner = rs.getString("OWNER"); + final StringProperties options = new StringProperties(rs); + //String args = rs.getString("arguments"); //func.setArguments(args); + final DBFunction func = new DBFunction(name, options, schema, owner, Collections.emptySet(), sql); listFunction.put(name, func); } } catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); + final String msg = lang.getValue("errors", "adapter", "fnc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } return listFunction; @@ -642,9 +782,8 @@ public Map getFunctions(String schema) { @Override public DBFunction getFunction(String schema, String name) { - DBFunction func = null; - String query = + final String query = "SELECT f.owner, f.object_name, (select listagg(DATA_TYPE, ' ' ) within group (order by DATA_TYPE) from ALL_ARGUMENTS " + "WHERE object_name = f.OBJECT_NAME AND owner = f.owner) arguments, (select dbms_metadata.get_ddl('FUNCTION', f.object_name, f.owner) AS DDL from dual) AS DDL \n" + "FROM all_objects f WHERE f.owner = '" + schema +"' and " + @@ -652,250 +791,175 @@ public DBFunction getFunction(String schema, String name) { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { - while (rs.next()) { - String objName = rs.getString("OBJECT_NAME"); - String owner = rs.getString("OWNER"); - func = new DBFunction(objName, schema, owner); - //String args = rs.getString("arguments"); - //func.setArguments(args); - rowToProperties(rs,func.getOptions()); - } + if (!rs.next()) throw new ExceptionDBGitObjectNotFound("function is not found in database"); + + final String objName = rs.getString("OBJECT_NAME"); + final String owner = rs.getString("OWNER"); + final String sql = rs.getString("DDL"); + final StringProperties options = new StringProperties(rs); + + + //String args = rs.getString("arguments"); + //func.setArguments(args); + return new DBFunction(objName, options, schema, owner, Collections.emptySet(), sql); + } catch(Exception e) { - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "fnc").toString(), e); + final String msg = lang.getValue("errors", "adapter", "fnc").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - return func; } @Override public DBTableData getTableDataPortion(String schema, String nameTable, int portionIndex, int tryNumber) { - DBTableData data = new DBTableData(); - + + final int portionSize = DBGitConfig.getInstance().getInteger("core", "PORTION_SIZE", DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000)); + final int begin = 1 + portionSize*portionIndex; + final int end = portionSize + portionSize*portionIndex; + + final String dataQuery = + "SELECT * FROM (" + + " SELECT f.*, ROW_NUMBER() OVER (ORDER BY rowid) DBGIT_ROW_NUM " + + " FROM " + schema + "." + nameTable + " f" + + ") " + + "WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end; + try { - int portionSize = DBGitConfig.getInstance().getInteger("core", "PORTION_SIZE", DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000)); - int begin = 1 + portionSize*portionIndex; - int end = portionSize + portionSize*portionIndex; - String dataQuery = - "SELECT * FROM (" + - " SELECT f.*, ROW_NUMBER() OVER (ORDER BY rowid) DBGIT_ROW_NUM " + - " FROM " + schema + "." + nameTable + " f" + - ") " + - "WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end; - - try(Statement st = getConnection().createStatement(); ){ - ResultSet rs = st.executeQuery(dataQuery); - data.setResultSet(rs); - } - return data; + return new DBTableData(getConnection(), dataQuery); + } catch(Exception e) { + final int maxTriesCount = DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000)); + final int tryDelay = DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000)); + ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - try { - if (tryNumber <= DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000))) { - try { - TimeUnit.SECONDS.sleep(DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000))); - } catch (InterruptedException e1) { - throw new ExceptionDBGitRunTime(e1.getMessage()); - } - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("errors", "dataTable", "loadPortionError") - .withParams(String.valueOf(tryNumber)) - , messageLevel - ); - return getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); + if (tryNumber <= maxTriesCount) { + + final String waitMessage = DBGitLang.getInstance() + .getValue("errors", "dataTable", "wait") + .withParams(String.valueOf(tryDelay)); + + final String tryAgainMessage = DBGitLang.getInstance() + .getValue("errors", "dataTable", "tryAgain") + .withParams(String.valueOf(tryNumber)); + + ConsoleWriter.println(waitMessage, messageLevel); + try { TimeUnit.SECONDS.sleep(tryDelay); } catch (InterruptedException e1) { + throw new ExceptionDBGitRunTime(e1.getMessage()); } - } catch (Exception e1) { - // TODO Auto-generated catch block - e1.printStackTrace(); - } - try { - getConnection().rollback(); - } catch (Exception e2) { - logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); + ConsoleWriter.println(tryAgainMessage, messageLevel); + return getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); + + } else { + final String msg = DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); } - throw new ExceptionDBGitRunTime(e.getMessage()); } } @Override public DBTableData getTableData(String schema, String nameTable) { - String tableName = schema + "." + nameTable; + final String tableName = schema + "." + nameTable; + final Boolean isFetchLimited = DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true)); + final int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH)); + final String dataQuery = "select * from " + tableName; try { - DBTableData data = new DBTableData(); - - int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH)); - - if (DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true))) { - Statement st = getConnection().createStatement(); - String query = "select COALESCE(count(*), 0) row_count from ( select 1 from "+ - tableName+" where ROWNUM <= " + (maxRowsCount + 1) + " ) tbl"; - ResultSet rs = st.executeQuery(query); - rs.next(); - if (rs.getInt("row_count") > maxRowsCount) { - data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); - return data; + + if (isFetchLimited) { + final String rowsCountQuery = + "select COALESCE(count(*), 0) row_count " + + "from ( " + + " select 1 " + + " from " + tableName+ " " + + " where ROWNUM <= " + (maxRowsCount + 1) + " " + + ") tbl"; + try(Statement st = getConnection().createStatement(); ResultSet rs = st.executeQuery(rowsCountQuery);){ + + if(!rs.next()) throw new ExceptionDBGitRunTime("empty rows count resultset"); + + if (rs.getInt("row_count") > maxRowsCount) { + return new DBTableData(DBTableData.ERROR_LIMIT_ROWS); + } + } - } - Statement st = getConnection().createStatement(); - ResultSet rs = st.executeQuery("select * from "+tableName); - data.setResultSet(rs); - return data; - - } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - try { - getConnection().rollback(); - } catch (Exception e2) { - logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); } - throw new ExceptionDBGitRunTime(e.getMessage()); + + return new DBTableData(getConnection(), dataQuery); + + } catch(Exception e) { + final String msg = DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } -/* - @Override - public DBTableRow getTableRow(String schema, String nameTable, Object id) { - // TODO Auto-generated method stub - return null; - } -*/ + @Override public Map getUsers() { - Map listUser = new HashMap(); - try { - String query = "SELECT USERNAME FROM DBA_USERS WHERE USERNAME != 'PUBLIC' AND USERNAME != 'SYSTEM'\n" + - "AND USERNAME != 'SYS' AND USERNAME != 'APPQOSSYS' AND USERNAME != 'OUTLN' \n" + - "AND USERNAME != 'DIP' AND USERNAME != 'DBSNMP' AND USERNAME != 'ORACLE_OCM' ORDER BY USERNAME"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); + final Map listUser = new HashMap(); + final String query = + "SELECT USERNAME FROM DBA_USERS WHERE USERNAME != 'PUBLIC' AND USERNAME != 'SYSTEM'\n" + + "AND USERNAME != 'SYS' AND USERNAME != 'APPQOSSYS' AND USERNAME != 'OUTLN' \n" + + "AND USERNAME != 'DIP' AND USERNAME != 'DBSNMP' AND USERNAME != 'ORACLE_OCM' ORDER BY USERNAME"; + + try ( + Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query); + ){ + while(rs.next()){ - String name = rs.getString(1); - DBUser user = new DBUser(name); + final String name = rs.getString(1); + final StringProperties options = new StringProperties(rs); + + final DBUser user = new DBUser(name, options); listUser.put(name, user); } - stmt.close(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "users") + ": " +e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "users") + ": " + e.getMessage()); + + } catch(Exception e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "users"); + throw new ExceptionDBGitRunTime(msg, e); } + return listUser; } @Override public Map getRoles() { - Map listRole = new HashMap(); - try { - String query = "SELECT R.GRANTEE, \n" + - "R.GRANTED_ROLE, R.ADMIN_OPTION, R.DEFAULT_ROLE FROM DBA_ROLE_PRIVS R \n" + - "WHERE R.GRANTEE = (SELECT USERNAME FROM DBA_USERS WHERE USERNAME = R.GRANTEE AND\n" + - "USERNAME != 'PUBLIC' AND USERNAME != 'SYSTEM'\n" + - "AND USERNAME != 'SYS' AND USERNAME != 'APPQOSSYS' AND USERNAME != 'OUTLN' \n" + - "AND USERNAME != 'DIP' AND USERNAME != 'DBSNMP' AND USERNAME != 'ORACLE_OCM')"; - Connection connect = getConnection(); - Statement stmt = connect.createStatement(); + final Map listRole = new HashMap(); + final String query = + "SELECT R.GRANTEE, \n" + + "R.GRANTED_ROLE, R.ADMIN_OPTION, R.DEFAULT_ROLE FROM DBA_ROLE_PRIVS R \n" + + "WHERE R.GRANTEE = (SELECT USERNAME FROM DBA_USERS WHERE USERNAME = R.GRANTEE AND\n" + + "USERNAME != 'PUBLIC' AND USERNAME != 'SYSTEM'\n" + + "AND USERNAME != 'SYS' AND USERNAME != 'APPQOSSYS' AND USERNAME != 'OUTLN' \n" + + "AND USERNAME != 'DIP' AND USERNAME != 'DBSNMP' AND USERNAME != 'ORACLE_OCM')"; + try ( + Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query); + ) { + while(rs.next()){ - String name = rs.getString("GRANTED_ROLE"); - DBRole role = new DBRole(name); - rowToProperties(rs, role.getOptions()); - listRole.put(name, role); - } - stmt.close(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "roles") + ": " + e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "roles") + ": " + e.getMessage()); - } - return listRole; - } + final String name = rs.getString("GRANTED_ROLE"); + final StringProperties options = new StringProperties(rs); - @Override - public boolean userHasRightsToGetDdlOfOtherUsers() { - try { - String userName = getConnection().getSchema(); - - if (userName.equalsIgnoreCase("SYS")) - return true; - - PreparedStatement stmt = getConnection().prepareStatement - ("SELECT count(1) cnt FROM DBA_ROLE_PRIVS WHERE GRANTEE = ? and GRANTED_ROLE = 'SELECT_CATALOG_ROLE'"); - stmt.setString(1, userName); - ResultSet resultSet = stmt.executeQuery(); - resultSet.next(); - - if (resultSet.getInt(1) == 0) { - return false; - } else { - return true; + final DBRole role = new DBRole(name, options); + listRole.put(name, role); } - } catch (SQLException e) { - logger.error(e.getMessage()); - return false; - } - } - - @Override - public IFactoryDBBackupAdapter getBackupAdapterFactory() { - return backupFactory; - } - @Override - public DbType getDbType() { - return DbType.ORACLE; - } - - @Override - public String getDbVersion() { - try { - PreparedStatement stmt = getConnection().prepareStatement("SELECT version FROM V$INSTANCE"); - ResultSet resultSet = stmt.executeQuery(); - resultSet.next(); - - String result = resultSet.getString("version"); - resultSet.close(); - stmt.close(); - - return result; - } catch (SQLException e) { - return ""; + } catch(Exception e) { + final DBGitLang msg = lang.getValue("errors", "adapter", "roles"); + throw new ExceptionDBGitRunTime(msg, e); } - } - @Override - public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit { - try { - Statement st = connect.createStatement(); - ResultSet rs = st.executeQuery("select count(*) cnt from all_users where USERNAME = '" + schemaName.toUpperCase() + "'"); - rs.next(); - if (rs.getInt("cnt") == 0) { - StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql()); - stLog.execute("create USER \"" + schemaName.toUpperCase() + "\"\r\n" + - "IDENTIFIED BY \"" + schemaName.toUpperCase() + "\"\r\n" + - "DEFAULT TABLESPACE \"SYSTEM\"\r\n" + - "TEMPORARY TABLESPACE \"TEMP\"\r\n" + - "ACCOUNT UNLOCK"); - - stLog.execute("ALTER USER \"" + schemaName.toUpperCase() + "\" QUOTA UNLIMITED ON SYSTEM"); - stLog.close(); - } - - rs.close(); - st.close(); - } catch (SQLException e) { - throw new ExceptionDBGit(lang.getValue("errors", "adapter", "createSchema") + ": " + e.getLocalizedMessage()); - } - + return listRole; } - @Override - public boolean isReservedWord(String word) { - Set reservedWords = new HashSet<>(); - + + static { reservedWords.add("ACCESS"); reservedWords.add("ADD"); reservedWords.add("ALL"); @@ -1005,27 +1069,5 @@ public boolean isReservedWord(String word) { reservedWords.add("WHENEVER"); reservedWords.add("WHERE"); reservedWords.add("WITH"); - - return reservedWords.contains(word.toUpperCase()); - } - - @Override - public IFactoryDBConvertAdapter getConvertAdapterFactory() { - return convertFactory; - } - - - @Override - public void createRoleIfNeed(String roleName) throws ExceptionDBGit { - } - - @Override - public String getDefaultScheme() throws ExceptionDBGit { - try { - return getConnection().getSchema(); - } catch (SQLException e) { - throw new ExceptionDBGit(lang.getValue("errors", "adapter", "getSchema") + ": " + e.getLocalizedMessage()); - } - } } diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java index 3041ad2..0f0bc42 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBRestoreTableDataOracle.java @@ -1,15 +1,9 @@ package ru.fusionsoft.dbgit.oracle; -import java.io.BufferedReader; -import java.io.File; import java.io.FileInputStream; -import java.io.FileNotFoundException; import java.io.IOException; -import java.io.InputStreamReader; -import java.sql.Clob; import java.sql.Connection; import java.sql.ResultSet; -import java.sql.SQLException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collection; @@ -17,7 +11,6 @@ import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; -import java.util.Set; import java.util.StringJoiner; import java.util.TreeMap; import java.util.stream.Collectors; @@ -43,7 +36,6 @@ import ru.fusionsoft.dbgit.meta.IMetaObject; import ru.fusionsoft.dbgit.meta.MetaTable; import ru.fusionsoft.dbgit.meta.MetaTableData; -import ru.fusionsoft.dbgit.statement.PrepareStatementLogging; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; @@ -81,7 +73,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if (getAdapter().getTable(schema, currentTableData.getTable().getName()) != null) { currentTableData.setDataTable(getAdapter().getTableData(schema, currentTableData.getTable().getName())); - ResultSet rs = currentTableData.getDataTable().getResultSet(); + ResultSet rs = currentTableData.getDataTable().resultSet(); TreeMapRowData mapRows = new TreeMapRowData(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index e0fe3f8..aa80614 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -3,10 +3,12 @@ import java.sql.*; import java.text.MessageFormat; +import java.time.Period; import java.util.*; import java.util.concurrent.TimeUnit; import com.diogonunes.jcdp.color.api.Ansi; +import com.google.common.collect.ImmutableMap; import org.apache.commons.lang3.exception.ExceptionUtils; import ru.fusionsoft.dbgit.adapters.*; import ru.fusionsoft.dbgit.core.*; @@ -14,6 +16,8 @@ import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.dbobjects.*; import ru.fusionsoft.dbgit.meta.IMapMetaObject; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.TreeMapMetaObject; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; @@ -24,11 +28,11 @@ public class DBAdapterPostgres extends DBAdapter { - private Logger logger = LoggerUtil.getLogger(this.getClass()); - private FactoryDBAdapterRestorePostgres restoreFactory = new FactoryDBAdapterRestorePostgres(); - private FactoryDbConvertAdapterPostgres convertFactory = new FactoryDbConvertAdapterPostgres(); - private FactoryDBBackupAdapterPostgres backupFactory = new FactoryDBBackupAdapterPostgres(); - private static Set reservedWords = new HashSet<>(); + private final Logger logger = LoggerUtil.getLogger(this.getClass()); + private final FactoryDBAdapterRestorePostgres restoreFactory = new FactoryDBAdapterRestorePostgres(); + private final FactoryDbConvertAdapterPostgres convertFactory = new FactoryDbConvertAdapterPostgres(); + private final FactoryDBBackupAdapterPostgres backupFactory = new FactoryDBBackupAdapterPostgres(); + private final static Set reservedWords = new HashSet<>(); @Override public IFactoryDBAdapterRestoteMetaData getFactoryRestore() { @@ -49,28 +53,29 @@ public void endUpdateDB() { @Override public IMapMetaObject loadCustomMetaObjects() { - return null; + return new TreeMapMetaObject(Collections.emptyList()); } @Override public Map getSchemes() { - Map listScheme = new HashMap(); - String query = + final Map listScheme = new HashMap(); + final String query = "select nspname,usename,nspacl from pg_namespace,pg_user where nspname!='pg_toast' and nspname!='pg_temp_1'"+ "and nspname!='pg_toast_temp_1' and nspname!='pg_catalog'"+ "and nspname!='information_schema' and nspname!='pgagent'"+ "and nspname!='pg_temp_3' and nspname!='pg_toast_temp_3'"+ "and usesysid = nspowner"; + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ while(rs.next()){ - String name = rs.getString("nspname"); - DBSchema scheme = new DBSchema(name, new StringProperties(rs)); + final String name = rs.getString("nspname"); + final DBSchema scheme = new DBSchema(name, new StringProperties(rs)); listScheme.put(name, scheme); } } catch(Exception e) { - String msg = lang.getValue("errors", "adapter", "schemes").toString(); + final String msg = lang.getValue("errors", "adapter", "schemes").toString(); throw new ExceptionDBGitRunTime(msg, e); } @@ -80,8 +85,8 @@ public Map getSchemes() { @Override public Map getTableSpaces() { - Map listTableSpace = new HashMap(); - String query = + final Map listTableSpace = new HashMap(); + final String query = "SELECT tblspaces.spcname,tblspaces.spcacl,tblspaces.spcoptions,users.usename,pg_tablespace_location(tblspacesoid.oid) " + "FROM pg_tablespace as tblspaces,pg_user as users,(Select oid FROM pg_tablespace where spcname!='pg_default' and spcname!='pg_global') as tblspacesoid " + "WHERE users.usesysid=tblspaces.spcowner and spcname!='pg_default' and spcname!='pg_global' and tblspacesoid.oid=tblspaces.oid"; @@ -89,13 +94,13 @@ public Map getTableSpaces() { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ while(rs.next()){ - String name = rs.getString("spcname"); - DBTableSpace dbTableSpace = new DBTableSpace(name, new StringProperties(rs)); + final String name = rs.getString("spcname"); + final DBTableSpace dbTableSpace = new DBTableSpace(name, new StringProperties(rs)); listTableSpace.put(name, dbTableSpace); } } catch(Exception e) { - String msg = lang.getValue("errors", "adapter", "tablespace").toString(); + final String msg = lang.getValue("errors", "adapter", "tablespace").toString(); throw new ExceptionDBGitRunTime(msg, e); } return listTableSpace; @@ -103,8 +108,8 @@ public Map getTableSpaces() { @Override public Map getSequences(String schema) { - Map listSequence = new HashMap<>(); - String query = MessageFormat.format( + final Map listSequence = new HashMap<>(); + final String query = MessageFormat.format( "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option, cl.relname as blocking_table \n" + "from pg_class cls \n" + " join pg_roles rol on rol.oid = cls.relowner \n" + @@ -118,21 +123,20 @@ public Map getSequences(String schema) { schema ); - try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) - { + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while(rs.next()){ - String nameSeq = rs.getString("sequence_name"); - String ownerSeq = rs.getString("blocking_table"); - Long valueSeq = 0L; + final String nameSeq = rs.getString("sequence_name"); + final String ownerSeq = rs.getString("blocking_table"); + final Long valueSeq = 0L; //TODO find actual value - DBSequence sequence = new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); + final DBSequence sequence = new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); listSequence.put(nameSeq, sequence); } } catch(Exception e) { - String msg = lang.getValue("errors", "adapter", "sequence").toString(); + final String msg = lang.getValue("errors", "adapter", "sequence").toString(); throw new ExceptionDBGitRunTime(msg, e); } @@ -142,7 +146,7 @@ public Map getSequences(String schema) { @Override public DBSequence getSequence(String schema, String name) { - String query = + final String query = "select s.sequence_name, rol.rolname as owner, s.start_value, s.minimum_value, s.maximum_value, s.increment, s.cycle_option, cl.relname as blocking_table \n" + "from pg_class cls \n" + " join pg_roles rol on rol.oid = cls.relowner \n" + @@ -155,33 +159,31 @@ public DBSequence getSequence(String schema, String name) { " and cls.relkind = 'S' and s.sequence_schema = :schema and s.sequence_name = :name "; try ( - PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "name", name)); + PreparedStatement stmt = preparedStatement(getConnection(), query, ImmutableMap.of("schema", schema, "name", name)); ResultSet rs = stmt.executeQuery(); ) { if (rs.next()) { - String nameSeq = rs.getString("sequence_name"); - String ownerSeq = rs.getString("blocking_table"); - Long valueSeq = 0L; //TODO find actual value - + final Long valueSeq = 0L; + final String nameSeq = rs.getString("sequence_name"); + final String ownerSeq = rs.getString("blocking_table"); return new DBSequence(nameSeq, new StringProperties(rs), schema, ownerSeq, Collections.emptySet(), valueSeq); + } else { - String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); throw new ExceptionDBGitObjectNotFound(msg); } } catch(Exception e) { - - String msg = lang.getValue("errors", "adapter", "sequence").toString(); + final String msg = lang.getValue("errors", "adapter", "sequence").toString(); throw new ExceptionDBGitRunTime(msg, e); - } } @Override public Map getTables(String schema) { - Map listTable = new HashMap(); - String query = + final Map listTable = new HashMap(); + final String query = "SELECT \n" + " tablename AS table_name,\n" + " tableowner AS owner,\n" + @@ -197,7 +199,7 @@ public Map getTables(String schema) { " and c1.relkind = 'r' AND c.contype = 'f'\n" + " ) " + " AS dependencies, \n" + - ( (getDbVersionNumber() > 10) + ( (getDbVersionNumber() >= 10) ? " pg_get_partkeydef((\n" + " SELECT oid \n" + " FROM pg_class \n" + @@ -217,16 +219,16 @@ public Map getTables(String schema) { "WHERE upper(schemaname) = upper(:schema)"; try ( - PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema)); + PreparedStatement stmt = preparedStatement(getConnection(), query, ImmutableMap.of("schema", schema)); ResultSet rs = stmt.executeQuery(); ) { while(rs.next()){ - String nameTable = rs.getString("table_name"); - String ownerTable = rs.getString("owner"); - String commentTable = rs.getString("table_comment"); - Set dependencies = rs.getArray("dependencies") != null + final String nameTable = rs.getString("table_name"); + final String ownerTable = rs.getString("owner"); + final String commentTable = rs.getString("table_comment"); + final Set dependencies = rs.getArray("dependencies") != null ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) : Collections.emptySet(); @@ -234,11 +236,11 @@ public Map getTables(String schema) { dependencies.add(schema + "/" + rs.getString("parent") + ".tbl"); } - DBTable table = new DBTable(nameTable, new StringProperties(rs), schema, ownerTable, dependencies, commentTable); + final DBTable table = new DBTable(nameTable, new StringProperties(rs), schema, ownerTable, dependencies, commentTable); listTable.put(nameTable, table); } } catch (Exception e) { - String msg = lang.getValue("errors", "adapter", "tables").toString(); + final String msg = lang.getValue("errors", "adapter", "tables").toString(); throw new ExceptionDBGitRunTime(msg, e); } return listTable; @@ -246,7 +248,7 @@ public Map getTables(String schema) { @Override public DBTable getTable(String schema, String name) { - String query = + final String query = "SELECT \n" + " tablename AS table_name,\n" + " tableowner AS owner,\n" + @@ -262,7 +264,7 @@ public DBTable getTable(String schema, String name) { " and c1.relkind = 'r' AND c.contype = 'f'\n" + " ) " + " AS dependencies, \n" + - ( (getDbVersionNumber() > 10) + ( (getDbVersionNumber() >= 10) ? " pg_get_partkeydef((\n" + " SELECT oid \n" + " FROM pg_class \n" + @@ -282,18 +284,17 @@ public DBTable getTable(String schema, String name) { "WHERE upper(schemaname) = upper(:schema)" + "AND tablename = :name"; try ( - PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "name", name)); + PreparedStatement stmt = preparedStatement(getConnection(), query, ImmutableMap.of("schema", schema, "name", name)); ResultSet rs = stmt.executeQuery(); ) { - if (rs.next()) { - String nameTable = rs.getString("table_name"); - String ownerTable = rs.getString("owner"); - String commentTable = rs.getString("table_comment"); - Set dependencies = rs.getArray("dependencies") != null - ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) - : Collections.emptySet(); + final String nameTable = rs.getString("table_name"); + final String ownerTable = rs.getString("owner"); + final String commentTable = rs.getString("table_comment"); + final Set dependencies = rs.getArray("dependencies") != null + ? new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())) + : Collections.emptySet(); if (rs.getString("parent") != null) { dependencies.add(schema + "/" + rs.getString("parent") + ".tbl"); @@ -302,12 +303,12 @@ public DBTable getTable(String schema, String name) { return new DBTable(nameTable, new StringProperties(rs), schema, ownerTable, dependencies, commentTable); } else { - String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); throw new ExceptionDBGitObjectNotFound(msg); } } catch(Exception e) { - String msg = lang.getValue("errors", "adapter", "tables").toString(); + final String msg = lang.getValue("errors", "adapter", "tables").toString(); throw new ExceptionDBGitRunTime(msg, e); } } @@ -338,50 +339,39 @@ public Map getTableFields(String schema, String nameTable "order by col.column_name "; try ( - PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "table", nameTable)); + PreparedStatement stmt = preparedStatement(getConnection(), query, ImmutableMap.of("schema", schema, "table", nameTable)); ResultSet rs = stmt.executeQuery(); ) { while(rs.next()){ - DBTableField field = new DBTableField(); - String typeSQL = getFieldType(rs); - String nameField = rs.getString("column_name"); - String descField = rs.getString("description"); - String columnDefault = rs.getString("column_default"); - boolean isFixed = rs.getBoolean("fixed"); - boolean isNameExactly = !rs.getString("column_name").equals(rs.getString("column_name").toLowerCase()); - boolean isPrimaryKey = rs.getString("constraint_name") != null; - boolean isNullable = !typeSQL.toLowerCase().contains("not null"); - FieldType typeUniversal = FieldType.fromString(rs.getString("tp")); - int length = rs.getInt("character_maximum_length"); - int precision = rs.getInt("numeric_precision"); - int scale = rs.getInt("numeric_scale"); - int ordinalPosition = rs.getInt("ordinal_position"); - //TODO more verbose type override - typeUniversal = typeUniversal.equals(FieldType.TEXT) ? FieldType.STRING_NATIVE : typeUniversal; - - field.setName(nameField); - field.setDescription(descField); - field.setNameExactly(isNameExactly); - field.setIsPrimaryKey(isPrimaryKey); - field.setTypeUniversal(typeUniversal); - field.setTypeSQL(typeSQL); - field.setIsNullable(isNullable); - field.setFixed(false); - field.setLength(length); - field.setPrecision(precision); - field.setScale(scale); - field.setFixed(isFixed); - field.setOrder(ordinalPosition); - field.setDefaultValue(columnDefault); + final String typeSQL = getFieldType(rs); + final String nameField = rs.getString("column_name"); + final String descField = rs.getString("description"); + final String columnDefault = rs.getString("column_default"); + final boolean isFixed = rs.getBoolean("fixed"); + final boolean isPrimaryKey = rs.getString("constraint_name") != null; + final boolean isNullable = !typeSQL.toLowerCase().contains("not null"); + final FieldType typeUniversal = FieldType.fromString(rs.getString("tp")); + final FieldType actualTypeUniversal = typeUniversal.equals(FieldType.TEXT) ? FieldType.STRING_NATIVE : typeUniversal; + final int length = rs.getInt("character_maximum_length"); + final int precision = rs.getInt("numeric_precision"); + final int scale = rs.getInt("numeric_scale"); + final int ordinalPosition = rs.getInt("ordinal_position"); + + + final DBTableField field = new DBTableField( + nameField, descField, isPrimaryKey, isNullable, + typeSQL, actualTypeUniversal, ordinalPosition, columnDefault, + length, scale, precision, isFixed + ); listField.put(nameField, field); } } catch(Exception e) { - String msg = lang.getValue("errors", "adapter", "tables").toString(); + final String msg = lang.getValue("errors", "adapter", "tableData").toString(); throw new ExceptionDBGitRunTime(msg, e); } @@ -390,7 +380,7 @@ public Map getTableFields(String schema, String nameTable private String getFieldType(ResultSet rs) { try { - StringBuilder type = new StringBuilder(); + final StringBuilder type = new StringBuilder(); type.append(rs.getString("dtype")); Integer max_length = rs.getInt("character_maximum_length"); @@ -402,16 +392,16 @@ private String getFieldType(ResultSet rs) { } return type.toString(); - }catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tables").toString(), e); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "tables").toString(), e); + } catch(Exception e) { + final String msg = lang.getValue("errors", "adapter", "tables").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override public Map getIndexes(String schema, String nameTable) { - Map indexes = new HashMap<>(); - String query = + final Map indexes = new HashMap<>(); + final String query = "SELECT " + " i.schemaname,\r\n" + " i.tablename, \r\n" + @@ -429,16 +419,16 @@ public Map getIndexes(String schema, String nameTable) { "-- AND idx.indisunique=false "; try ( - PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "table", nameTable)); + PreparedStatement stmt = preparedStatement(getConnection(), query, ImmutableMap.of("schema", schema, "table", nameTable)); ResultSet rs = stmt.executeQuery(); ){ while(rs.next()){ - String name = rs.getString("indexname"); - String owner = rs.getString("owner"); - String ddl = rs.getString("ddl"); - DBIndex index = new DBIndex(name, new StringProperties(rs), schema, owner, Collections.emptySet(), ddl); + final String name = rs.getString("indexname"); + final String owner = rs.getString("owner"); + final String ddl = rs.getString("ddl"); + final DBIndex index = new DBIndex(name, new StringProperties(rs), schema, owner, Collections.emptySet(), ddl); indexes.put(name, index); } @@ -453,7 +443,7 @@ public Map getIndexes(String schema, String nameTable) { @Override public Map getConstraints(String schema, String nameTable) { - Map constraints = new HashMap<>(); + final Map constraints = new HashMap<>(); /* String query = "select conname as constraint_name,contype as constraint_type, " + " pg_catalog.pg_get_constraintdef(r.oid, true) as ddl " + @@ -465,7 +455,7 @@ public Map getConstraints(String schema, String nameTable) " relname = :table and nspname = :schema and c.relkind = 'r'"; */ - String query = + final String query = "SELECT " + " t.tableowner as owner," + " conname as constraint_name," + @@ -479,17 +469,17 @@ public Map getConstraints(String schema, String nameTable) "AND rel.relname = :table"; try ( - PreparedStatement stmt = preparedStatement(getConnection(), query, Map.of("schema", schema, "table", nameTable)); + PreparedStatement stmt = preparedStatement(getConnection(), query, ImmutableMap.of("schema", schema, "table", nameTable)); ResultSet rs = stmt.executeQuery(); ){ while(rs.next()){ - String name = rs.getString("constraint_name"); - String type = rs.getString("constraint_type"); - String owner = rs.getString("owner"); - String ddl = rs.getString("ddl"); - StringProperties options = new StringProperties(rs); - DBConstraint con = new DBConstraint(name, options, schema, owner, Collections.emptySet(), ddl, type); + final String name = rs.getString("constraint_name"); + final String type = rs.getString("constraint_type"); + final String owner = rs.getString("owner"); + final String ddl = rs.getString("ddl"); + final StringProperties options = new StringProperties(rs); + final DBConstraint con = new DBConstraint(name, options, schema, owner, Collections.emptySet(), ddl, type); constraints.put(con.getName(), con); } @@ -504,8 +494,8 @@ public Map getConstraints(String schema, String nameTable) @Override public Map getViews(String schema) { - Map listView = new HashMap(); - String query = + final Map listView = new HashMap(); + final String query = "select nsp.nspname as object_schema, cls.relname as object_name, rol.rolname as owner, \n" + "'create or replace view ' || nsp.nspname || '.' || cls.relname || ' as ' || pg_get_viewdef(cls.oid) as ddl, (\n" + " select array_agg(distinct source_ns.nspname || '/' || source_table.relname || '.vw') as dependencySam\n" + @@ -532,12 +522,12 @@ public Map getViews(String schema) { try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);){ while(rs.next()){ - String objectName = rs.getString("object_name"); - String objectSchema = rs.getString("object_schema"); - String owner = rs.getString("owner"); - String ddl = rs.getString("ddl"); - StringProperties options = new StringProperties(rs); - Set dependencies = rs.getArray("dependencies") == null + final String objectName = rs.getString("object_name"); + final String objectSchema = rs.getString("object_schema"); + final String owner = rs.getString("owner"); + final String ddl = rs.getString("ddl"); + final StringProperties options = new StringProperties(rs); + final Set dependencies = rs.getArray("dependencies") == null ? Collections.emptySet() : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); @@ -546,9 +536,8 @@ public Map getViews(String schema) { } } catch (Exception e) { - logger.error(e.getMessage()); - System.out.println(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); - throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "views") + ": "+ e.getMessage()); + final DBGitLang msg = lang.getValue("errors", "adapter", "views"); + throw new ExceptionDBGitRunTime(msg, e); } return listView; @@ -634,6 +623,7 @@ public Map getTriggers(String schema) { DBTrigger trigger = new DBTrigger(name, options, schema, owner, dependencies, sql); listTrigger.put(name, trigger); } + }catch(Exception e) { throw new ExceptionDBGitRunTime(lang.getValue("errors", "adapter", "triggers").toString(), e); } @@ -694,7 +684,7 @@ public Map getProcedures(String schema) { "FROM pg_catalog.pg_proc p\n" + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - ( (getDbVersionNumber() > 10) + ( (getDbVersionNumber() >= 10) ? "WHERE p.prokind = 'p' \n" : "WHERE 1=0 \n" ) + @@ -735,7 +725,7 @@ public DBProcedure getProcedure(String schema, String name) { "FROM pg_catalog.pg_proc p\n" + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - ( (getDbVersionNumber() > 10) + ( (getDbVersionNumber() >= 10) ? "WHERE p.prokind = 'p' \n" : "WHERE 1=0 \n" ) + @@ -775,7 +765,7 @@ public Map getFunctions(String schema) { "FROM pg_catalog.pg_proc p\n" + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - ( (getDbVersionNumber() > 10) + ( (getDbVersionNumber() >= 10) ? "WHERE p.prokind = 'f' \n" : "WHERE 1=1 " )+ @@ -815,7 +805,7 @@ public DBFunction getFunction(String schema, String name) { "FROM pg_catalog.pg_proc p\n" + " JOIN pg_catalog.pg_roles u ON u.oid = p.proowner\n" + " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + - ( (getDbVersionNumber() > 10) + ( (getDbVersionNumber() >= 10) ? "WHERE p.prokind = 'f' \n" : "WHERE 1=1 \n" ) + @@ -851,120 +841,109 @@ public DBFunction getFunction(String schema, String name) { @Override public DBTableData getTableDataPortion(String schema, String nameTable, int portionIndex, int tryNumber) { - DBTableData data = new DBTableData(); - + final DBGitConfig config = DBGitConfig.getInstance(); try { - final Integer maxRowsCountDefault = DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH); - int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", maxRowsCountDefault); - - final Boolean isFetchLimitedDefault = DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true); - final Boolean isFetchLimited = DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", isFetchLimitedDefault); - - String tableRowsCountQuery = + final boolean isFetchLimitedDefault = config.getBooleanGlobal("core", "LIMIT_FETCH", true); + final boolean isFetchLimited = config.getBoolean("core", "LIMIT_FETCH", isFetchLimitedDefault); + final int maxRowsCountDefault = config.getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH); + final int maxRowsCount = config.getInteger("core", "MAX_ROW_COUNT_FETCH", maxRowsCountDefault); + final int portionSize = config.getInteger("core", "PORTION_SIZE", config.getIntegerGlobal("core", "PORTION_SIZE", 1000)); + final int portionBegin = 1 + portionSize*portionIndex; + final int portionEnd = portionSize + portionSize*portionIndex; + + final String tableRowsCountQuery = "select COALESCE(count(*), 0) kolvo " + "from ( " + " select 1 from " + escapeNameIfNeeded(schema) + "." + escapeNameIfNeeded(nameTable) + " limit " + (maxRowsCount + 1) + " " + ") tbl"; + final String dataQuery = + " SELECT * FROM \r\n" + + " (SELECT f.*, ROW_NUMBER() OVER (ORDER BY ctid) DBGIT_ROW_NUM FROM " + escapeNameIfNeeded(schema) + "." + escapeNameIfNeeded(nameTable) + " f) s\r\n" + + " WHERE DBGIT_ROW_NUM BETWEEN " + portionBegin + " and " + portionEnd; + + if (isFetchLimited) { try(Statement st = getConnection().createStatement(); ResultSet rs = st.executeQuery(tableRowsCountQuery);){ if(!rs.next()) { String msg = "error fetch table rows count"; throw new ExceptionDBGitRunTime(msg); - } - if (rs.getInt("kolvo") > maxRowsCount) { - data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); - return data; + } else if (rs.getInt("kolvo") > maxRowsCount) { + return new DBTableData(DBTableData.ERROR_LIMIT_ROWS); } } } - int portionSize = DBGitConfig.getInstance().getInteger("core", "PORTION_SIZE", DBGitConfig.getInstance().getIntegerGlobal("core", "PORTION_SIZE", 1000)); + return new DBTableData(getConnection(), dataQuery); - int begin = 1 + portionSize*portionIndex; - int end = portionSize + portionSize*portionIndex; - //close statement or I should not? And what if trywithresources?? - Statement st = getConnection().createStatement(); - String query = - " SELECT * FROM \r\n" + - " (SELECT f.*, ROW_NUMBER() OVER (ORDER BY ctid) DBGIT_ROW_NUM FROM " + escapeNameIfNeeded(schema) + "." + escapeNameIfNeeded(nameTable) + " f) s\r\n" + - " WHERE DBGIT_ROW_NUM BETWEEN " + begin + " and " + end; - ResultSet rs = st.executeQuery(query); + } catch(Exception e) { - data.setResultSet(rs); - return data; + final int maxTriesCount = DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000)); + final int tryDelay = DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000)); - } catch(Exception e) { ConsoleWriter.println(e.getLocalizedMessage(), messageLevel); ConsoleWriter.detailsPrintln(ExceptionUtils.getStackTrace(e), messageLevel); - logger.error(DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(), e); + logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - try { - final Integer tryCountDefault = DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_COUNT", 1000); - final Integer tryCount = DBGitConfig.getInstance().getInteger("core", "TRY_COUNT", tryCountDefault); + if (tryNumber <= maxTriesCount) { - if (tryNumber <= tryCount) { - try { - TimeUnit.SECONDS.sleep(DBGitConfig.getInstance().getInteger("core", "TRY_DELAY", DBGitConfig.getInstance().getIntegerGlobal("core", "TRY_DELAY", 1000))); - } catch (InterruptedException interruptedException) { - throw new ExceptionDBGitRunTime(interruptedException); - } + final String waitMessage = DBGitLang.getInstance() + .getValue("errors", "dataTable", "wait") + .withParams(String.valueOf(tryDelay)); - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("errors", "dataTable", "loadPortionError") - .withParams(String.valueOf(tryNumber)) - , messageLevel - ); + final String tryAgainMessage = DBGitLang.getInstance() + .getValue("errors", "dataTable", "tryAgain") + .withParams(String.valueOf(tryNumber)); - getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); + ConsoleWriter.println(waitMessage, messageLevel); + try { TimeUnit.SECONDS.sleep(tryDelay); } catch (InterruptedException e1) { + throw new ExceptionDBGitRunTime(e1.getMessage()); } - } catch (Exception e1) { - // TODO Auto-generated catch block - e1.printStackTrace(); - } + ConsoleWriter.println(tryAgainMessage, messageLevel); + return getTableDataPortion(schema, nameTable, portionIndex, tryNumber++); - throw new ExceptionDBGitRunTime(e); + } else { + final String msg = DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); + } } } @Override public DBTableData getTableData(String schema, String nameTable) { - String tableName = escapeNameIfNeeded(schema)+"."+ escapeNameIfNeeded(nameTable); + final String tableName = escapeNameIfNeeded(schema)+"."+ escapeNameIfNeeded(nameTable); + final int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH)); + final Boolean isFetchLimited = DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true)); try { - DBTableData data = new DBTableData(); - - int maxRowsCount = DBGitConfig.getInstance().getInteger("core", "MAX_ROW_COUNT_FETCH", DBGitConfig.getInstance().getIntegerGlobal("core", "MAX_ROW_COUNT_FETCH", MAX_ROW_COUNT_FETCH)); - - if (DBGitConfig.getInstance().getBoolean("core", "LIMIT_FETCH", DBGitConfig.getInstance().getBooleanGlobal("core", "LIMIT_FETCH", true))) { - Statement st = getConnection().createStatement(); - String query = "select COALESCE(count(*), 0) kolvo from ( select 1 from "+ - tableName + " limit " + (maxRowsCount + 1) + " ) tbl"; - ResultSet rs = st.executeQuery(query); - rs.next(); - if (rs.getInt("kolvo") > maxRowsCount) { - data.setErrorFlag(DBTableData.ERROR_LIMIT_ROWS); - return data; + if (isFetchLimited) { + + String query = + "select COALESCE(count(*), 0) kolvo " + + "from ( " + + " select 1 from "+ tableName + + " limit " + (maxRowsCount + 1) + + " ) tbl"; + + try(Statement st = getConnection().createStatement(); ResultSet rs = st.executeQuery(query);){ + if(!rs.next()) throw new ExceptionDBGitRunTime("Could not execute rows count query"); + if (rs.getInt("kolvo") > maxRowsCount) { + return new DBTableData(DBTableData.ERROR_LIMIT_ROWS); + } } } - Statement st = getConnection().createStatement(); - ResultSet rs = st.executeQuery("select * from "+tableName); - data.setResultSet(rs); + final String tdQuery = "select * from " + tableName; + return new DBTableData(getConnection(), tdQuery); //TODO other state + //TODO find out what does 'other state' todo comment mean... - return data; } catch(Exception e) { - logger.error(lang.getValue("errors", "adapter", "tableData").toString(), e); - try { - getConnection().rollback(); - } catch (Exception e2) { - logger.error(lang.getValue("errors", "adapter", "rollback").toString(), e2); - } - throw new ExceptionDBGitRunTime(e.getMessage()); + final String msg = DBGitLang.getInstance().getValue("errors", "adapter", "tableData").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @@ -984,7 +963,6 @@ public Map getUsers() { } catch(Exception e) { throw new ExceptionDBGitRunTime(e); } - //connect.cre //select *from pg_catalog.pg_namespace; return listUser; } @@ -1022,98 +1000,96 @@ public Map getRoles() { } @Override - public boolean userHasRightsToGetDdlOfOtherUsers() { - return true; - } - + public boolean userHasRightsToGetDdlOfOtherUsers() { return true; } @Override - public IFactoryDBBackupAdapter getBackupAdapterFactory() { - return backupFactory; - } - + public IFactoryDBBackupAdapter getBackupAdapterFactory() { return backupFactory; } @Override - public DbType getDbType() { - return DbType.POSTGRES; - } - + public IFactoryDBConvertAdapter getConvertAdapterFactory() { return convertFactory; } + @Override + public DbType getDbType() { return DbType.POSTGRES; } @Override public String getDbVersion() { - try { - PreparedStatement stmt = getConnection().prepareStatement("SHOW server_version"); - ResultSet resultSet = stmt.executeQuery(); - resultSet.next(); + final String query = "SHOW server_version"; + try ( + PreparedStatement stmt = getConnection().prepareStatement(query); + ResultSet resultSet = stmt.executeQuery(); + ) { + + if(!resultSet.next()){ + final String msg = "failed to get schema data"; + throw new ExceptionDBGitRunTime(msg); + } - String result = resultSet.getString("server_version"); - resultSet.close(); - stmt.close(); + return resultSet.getString("server_version"); - return result; } catch (SQLException e) { - return ""; + final String msg = "failed to get database version"; + throw new ExceptionDBGitRunTime(msg, e); } } - @Override - public IFactoryDBConvertAdapter getConvertAdapterFactory() { - return convertFactory; - } + public String getDefaultScheme() throws ExceptionDBGit { return "public"; } + @Override + public boolean isReservedWord(String word) { return reservedWords.contains(word.toUpperCase()); } @Override - public void createSchemaIfNeed(String schemaName) throws ExceptionDBGit { - try { - Statement st = connect.createStatement(); - ResultSet rs = st.executeQuery("select count(*) cnt from information_schema.schemata where upper(schema_name) = '" + - schemaName.toUpperCase() + "'"); + public void createSchemaIfNeed(String schemaName) { + final String query = + "select count(*) cnt " + + "from information_schema.schemata " + + "where upper(schema_name) = '" + schemaName.toUpperCase() + "'"; - rs.next(); - if (rs.getInt("cnt") == 0) { - StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql()); - stLog.execute("create schema " + schemaName + ";\n"); + try (Statement st = connect.createStatement(); ResultSet rs = st.executeQuery(query);){ + + if(!rs.next()) { + final String msg = "failed to get schema data"; + throw new ExceptionDBGitRunTime(msg); + } - stLog.close(); + if (rs.getInt("cnt") == 0) { + try(StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql());){ + stLog.execute("create schema " + schemaName + ";\n"); + } + } else { + return; } - rs.close(); - st.close(); } catch (SQLException e) { - throw new ExceptionDBGit(lang.getValue("errors", "adapter", "createSchema") + ": " + e.getLocalizedMessage()); + final String msg = lang.getValue("errors", "adapter", "createSchema").toString(); + throw new ExceptionDBGitRunTime(msg, e); } } @Override - public void createRoleIfNeed(String roleName) throws ExceptionDBGit { - try { - Statement st = connect.createStatement(); - ResultSet rs = st.executeQuery("select count(*) cnt from pg_catalog.pg_roles where upper(rolname) = '" + - roleName.toUpperCase() + "'"); + public void createRoleIfNeed(String roleName) { + final String query = + "select count(*) cnt " + + "from pg_catalog.pg_roles " + + "where upper(rolname) = '" + roleName.toUpperCase() + "'"; - rs.next(); - if (rs.getInt("cnt") == 0) { - StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql()); - stLog.execute("CREATE ROLE " + roleName + " LOGIN PASSWORD '" + roleName + "'"); + try (Statement st = connect.createStatement(); ResultSet rs = st.executeQuery(query);) { - stLog.close(); + if(!rs.next()) { + final String msg = "failed to get role data"; + throw new ExceptionDBGitRunTime(msg); + } + + if (rs.getInt("cnt") == 0){ + try(StatementLogging stLog = new StatementLogging(connect, getStreamOutputSqlCommand(), isExecSql());) { + //TODO which kind of PASSWORD that equals to ROLE NAME? + stLog.execute("CREATE ROLE " + roleName + " LOGIN PASSWORD '" + roleName + "'"); + } + } else { + return; } - rs.close(); - st.close(); } catch (SQLException e) { - throw new ExceptionDBGit(lang.getValue("errors", "adapter", "createSchema") + ": " + e.getLocalizedMessage()); + final DBGitLang msg = lang.getValue("errors", "adapter", "createSchema"); + throw new ExceptionDBGitRunTime(msg, e); } } - @Override - public String getDefaultScheme() throws ExceptionDBGit { - return "public"; - } - - @Override - public boolean isReservedWord(String word) { - return reservedWords.contains(word.toUpperCase()); - } - - public String escapeNameIfNeeded(String name){ boolean shouldBeEscaped = !name.equals(name.toLowerCase()) || name.contains(".") diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index 3ecf0dd..1bafb11 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -78,7 +78,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { //actually load data from database currentTableData.setDataTable(getAdapter().getTableData(schema, currentTableData.getTable().getName())); - ResultSet rs = currentTableData.getDataTable().getResultSet(); + ResultSet rs = currentTableData.getDataTable().resultSet(); TreeMapRowData mapRows = new TreeMapRowData(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 286ee46..3627acc 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -678,9 +678,16 @@ public void enrichWithNotNullConstraints(MetaTable table){ } public DBConstraint constructNotNullDBConstraint(MetaTable table, DBTableField field){ - String name = "notnull_" + field.getName() + " (Transient)"; - String type = "nn"; - DBConstraint constraint = new DBConstraint(name, table.getTable().getSchema(), table.getTable().getOwner(), type); + final String name = "notnull_" + field.getName() + " (Transient)"; + final String type = "nn"; + final String sql = ""; + final StringProperties options = new StringProperties(); + final Set dependencies = Collections.emptySet(); + final DBTable dbTable = table.getTable(); + final String schema = dbTable.getSchema(); + final String owner = dbTable.getOwner(); + + DBConstraint constraint = new DBConstraint(name, options, schema, owner, dependencies, sql, type); constraint.getOptions().getChildren().put("column_name", new StringProperties(field.getName())); constraint.setSql(MessageFormat.format( @@ -689,6 +696,7 @@ public DBConstraint constructNotNullDBConstraint(MetaTable table, DBTableField f ); return constraint; } + /*public void removeIndexesPostgres(IMetaObject obj) throws Exception { IDBAdapter adapter = getAdapter(); Connection connect = adapter.getConnection(); diff --git a/src/main/java/ru/fusionsoft/dbgit/utils/StringProperties.java b/src/main/java/ru/fusionsoft/dbgit/utils/StringProperties.java index e7cb9ad..da14dd2 100644 --- a/src/main/java/ru/fusionsoft/dbgit/utils/StringProperties.java +++ b/src/main/java/ru/fusionsoft/dbgit/utils/StringProperties.java @@ -15,60 +15,60 @@ * */ public class StringProperties { - private String data = null; - private StringProperties parent = null; - private Map children = null; + private String data; + private Map children; public StringProperties() { - this.children = new TreeMap(); + this.children = new TreeMap<>(); + this.data = ""; } - public StringProperties(String data) { - this(); - this.data = data; + public StringProperties(String data) { + this.children = new TreeMap<>(); + this.data = data; + } + public StringProperties(Map children) { + this.children = children == null ? new TreeMap<>() : children; + this.data = ""; } - public StringProperties (ResultSet rs) { - + public StringProperties(ResultSet rs) { + this.children = new TreeMap<>(); + this.data = ""; try { - for (int i = 1; i <= rs.getMetaData().getColumnCount(); i++) { - if (rs.getString(i) == null) continue ; + final int columnCount = rs.getMetaData().getColumnCount(); + for (int i = 1; i <= columnCount; i++) { + + final String columnName = rs.getMetaData().getColumnName(i); + final String columnValue = rs.getString(i); - String columnName = rs.getMetaData().getColumnName(i); if (columnName.equalsIgnoreCase("dependencies")) continue ; + if (columnValue == null) continue ; + + final String cleanValue = cleanString(columnValue); + final String cleanName = columnName.toLowerCase(); - addChild(columnName.toLowerCase(), cleanString(rs.getString(i))); + addChild(cleanName, cleanValue); } } catch(Exception e) { throw new ExceptionDBGitRunTime(e); } } + - - public StringProperties addChild(String name) { - StringProperties childNode = new StringProperties(); - childNode.parent = this; - this.children.put(name, childNode); - return childNode; - } - - public StringProperties addChild(String name, StringProperties properties) { - this.children.put(name, properties); - properties.parent = this; - return properties; + public void addChild(String name, String stringValue) { + StringProperties valueOnlyNode = new StringProperties(stringValue); + this.children.put(name, valueOnlyNode); } - public StringProperties addChild(String name, String val) { - StringProperties childNode = addChild(name); - childNode.setData(val); - return childNode; + public void addChild(String name, StringProperties value) { + this.children.put(name, value); } - public StringProperties deleteChild(String name) { + public void deleteChild(String name) { if (children.containsKey(name)) { children.remove(name); } - return this; } public StringProperties xPath(String path) { @@ -93,10 +93,6 @@ public void setData(String data) { this.data = data; } - public StringProperties getParent() { - return parent; - } - public Map getChildren() { return children; } diff --git a/src/main/java/ru/fusionsoft/dbgit/yaml/DBGitYamlConstructor.java b/src/main/java/ru/fusionsoft/dbgit/yaml/DBGitYamlConstructor.java index 337a8da..45aa766 100644 --- a/src/main/java/ru/fusionsoft/dbgit/yaml/DBGitYamlConstructor.java +++ b/src/main/java/ru/fusionsoft/dbgit/yaml/DBGitYamlConstructor.java @@ -9,8 +9,8 @@ import org.yaml.snakeyaml.nodes.MappingNode; import org.yaml.snakeyaml.nodes.Node; import org.yaml.snakeyaml.nodes.ScalarNode; -import org.yaml.snakeyaml.nodes.Tag; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.utils.StringProperties; /** @@ -46,34 +46,31 @@ private class ConstructYamlStringProperties extends AbstractConstruct { @Override public Object construct(Node node) { if (node instanceof MappingNode) { - Object obj = constructMapping((MappingNode)node); - - StringProperties properties = new StringProperties(); - parseMap(properties, obj); - - return properties; + + final Map map = constructMapping((MappingNode)node); + return fromTreeNode(map); } if (node instanceof ScalarNode) { - //TODO - StringProperties properties = new StringProperties(); - - return properties; - } - return null; - } - - @SuppressWarnings("unchecked") - public void parseMap(StringProperties pr, Object obj) { - if (obj instanceof Map) { - Map map = (Map)obj; - for( String key : map.keySet()) { - StringProperties newPr = (StringProperties)pr.addChild(key); - parseMap(newPr, map.get(key)); - } - } else { - pr.setData((String)obj); + final String stringValue = constructScalar((ScalarNode)node).toString(); + return new StringProperties(stringValue); } + + throw new ExceptionDBGitRunTime("return null in construct! Gotcha!"); +// return null; } + + public StringProperties fromTreeNode(Object treeNode) { + try { + final Map map = (Map) treeNode; + final StringProperties constructedNode = new StringProperties(); + + map.forEach((key, value) -> constructedNode.addChild(key, fromTreeNode(value))); + return constructedNode; + + } catch (ClassCastException e) { + return new StringProperties(treeNode.toString()); + } + } } } \ No newline at end of file diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index 4835376..ef62488 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -241,7 +241,9 @@ errors: differentCount: Different count columns title and line fieldNotFound: Field {0} not found filesNotFound: Cound not find .data files in directories '{0}', put NULL values instead - loadPortionError: Error while getting portion of data, try {0} + tryAgain: Making attempt {0} getting portion of data... + wait: Error while getting portion of data, waiting {0} seconds before next try... + errorTableData: There was error while getting table data, error flag was ({0}) adapter: schemes: Error load schemes! tables: Error load tables! diff --git a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java index 07f192b..ee781c1 100644 --- a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java @@ -1,7 +1,9 @@ package ru.fusionsoft.dbgit; +import com.diogonunes.jcdp.color.api.Ansi; import com.google.common.collect.MapDifference; import com.google.common.collect.Maps; + import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.Option; import org.apache.commons.io.FileUtils; @@ -9,22 +11,17 @@ import org.eclipse.jgit.api.errors.GitAPIException; import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; import org.eclipse.jgit.internal.storage.dfs.InMemoryRepository; -import org.eclipse.jgit.internal.storage.file.FileRepository; -import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.transport.RefSpec; import org.junit.jupiter.api.*; import static org.junit.jupiter.api.Assertions.*; -import org.postgresql.jdbc.PgConnection; import ru.fusionsoft.dbgit.adapters.AdapterFactory; -import ru.fusionsoft.dbgit.adapters.DBAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.command.*; import ru.fusionsoft.dbgit.core.*; import ru.fusionsoft.dbgit.meta.IMapMetaObject; import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.postgres.DBAdapterPostgres; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import java.io.File; @@ -37,150 +34,114 @@ import java.util.*; -// 1. We use test repository in 'resources' folder -// 2. We use test database created in selected server -// 3. We have various test scenarios to test COMMANDS and their COMBINATIONS -// + CmdAdd - check add files from DATABASE to REPO -//CmdRm - check delete files, DBINDEX operations, CmdRestore interchange, -//CmdDump - check the same as CmdAdd -//CmdBackup - check add backup files to test DATABASE -// +- CmdRestore - lots of scenarios on 1. restore schema 2. delete objs 3. modify schema 4. modify data 5. backups -// + CmdCheckout -//CmdStatus CmdValid -// + CmdLink CmdInit CmdConfig -//CmdCommit CmdPush CmdPull CmdFetch -//CmdRemote CmdMerge CmdReset -//CmdSynonymSchema CmdHelp CmdClone -// - - @Tag("pgTest") @TestMethodOrder(MethodOrderer.OrderAnnotation.class) +@TestInstance(TestInstance.Lifecycle.PER_CLASS) public class DBGitTest { - static String repoUrl = "https://github.com/rocket-3/dbgit-test.git"; - static String repoBranch = "master"; - static String pgTestDbUrl = "jdbc:postgresql://0.0.0.0/"; - static String pgTestDbUser = /*"postgres";*/"testuser"; - static String pgTestDbPass = /*"pass";*/"s%G351as"; - static String pgTestDbCatalog = "testdatabasegit"; - static boolean eraseExistingCatalog = false; - static{ if(!eraseExistingCatalog) addCatalogToUrl(); } + static Path RESOURCES_REPO_DIR = new File( "src/test/resources/repo").toPath(); + static Path RECOURCES_REPO_GIT_DIR = RESOURCES_REPO_DIR.resolve(".git"); + + static String REPO_URL = "https://github.com/rocket-3/dbgit-test.git"; + static String REPO_BRANCH = "master"; + static List REPO_COMMIT_NUMBERS = new ArrayList<>(); + + static String TEST_DB_URL = "jdbc:postgresql://localhost/"; + static String TEST_DB_USER = "postgres"; + static String TEST_DB_PASS = "Kan:al*098"; + static String TEST_DB_CATALOG = "test#databasegit"; + static boolean TO_CREATE_CATALOG = true; + static int messageLevel = 0; + + //static String pgTestDbUrl = "jdbc:postgresql://135.181.94.98:31007/"; + //static String pgTestDbUser = "user"; + //static String pgTestDbPass = "42PoapGLGVnTdEYoUYFaFWXK"; private static void addCatalogToUrl() { - pgTestDbUrl = MessageFormat.format( + TEST_DB_URL = MessageFormat.format( "{0}{1}{2}", - pgTestDbUrl, - !pgTestDbUrl.endsWith("/") ? "/" : "", - pgTestDbCatalog + TEST_DB_URL, + !TEST_DB_URL.endsWith("/") ? "/" : "", + TEST_DB_CATALOG ); } - static List commitNumbers = new ArrayList<>(); - //Now commit numbers are loaded automaticvally - /*Arrays.asList( - "88673845e9891228d2ebb7ad3bdebb534ce8efbe", - "b1fecd7ebcf33a61fa7b962cb5e92ae6cdb8db64", - "831054e4eac9a1f0d1797b6f65ebd64e7d81f74f", - "d2b40808dd6df2d51d80bddbdcdfdabef7394373", - "4f3953d44743a539321d024871182eef8f1cd7f9" - );*/ - static Path resourcesRepoDirectory = new File( "src/test/resources/repo").toPath(); - static Path resourcesRepoGitDirectory = resourcesRepoDirectory.resolve(".git"); - - static Properties pgTestDbProps = new Properties(); - static DBConnection pgTestDbConnection = null; - - - @BeforeAll public static void setUp() throws Exception { - DBGit.initUrlInstance(resourcesRepoGitDirectory.toString(), false); + printMethodHead("Set up", null); + ConsoleWriter.setDetailedLog(true); + + FileUtils.cleanDirectory(RESOURCES_REPO_DIR.toFile()); + DBGit.initUrlInstance(RECOURCES_REPO_GIT_DIR.toString(), false); + dbgitClone(REPO_URL, String.valueOf(RESOURCES_REPO_DIR)); - if(commitNumbers.isEmpty()){ + configureTestDb(TO_CREATE_CATALOG); + + if(REPO_COMMIT_NUMBERS.isEmpty()){ loadCommitNumbersFromRepo(); } - configureTestDb(false); } @BeforeEach - public void init() throws Exception { - restoreDbLinkIfNeeded(); - } - - @Test - @Order(1) - public void CmdClone() throws Exception { - FileUtils.cleanDirectory(resourcesRepoDirectory.toFile()); - dbgitClone(repoUrl, String.valueOf(resourcesRepoDirectory)); - - - File gitFile = resourcesRepoDirectory.resolve(".git").toFile(); - File dbgitFile = resourcesRepoDirectory.resolve(".dbgit").toFile(); - File[] dbgitFiles = dbgitFile.listFiles(); - - assertTrue(gitFile.exists(), "'.git folder exists'"); - assertTrue(dbgitFile.exists(), "'.dbgit folder exists'"); - assertTrue(dbgitFiles != null && dbgitFiles.length > 0, "'.dbgit folder is not empty'"); - - ConsoleWriter.printlnGreen(MessageFormat.format("Number of files in .dbgit {0}", dbgitFiles.length )); - Arrays.asList(dbgitFiles).forEach(x->ConsoleWriter.printlnRed(x.getPath())); - + public void setUpEach() throws Exception { +// printMethodHead("Before each", null); + configureDBConnection(); } @Test - @Order(2) public void CmdLink() throws Exception { + printMethodHead("CmdLink", null); + CmdLink cmd = new CmdLink(); String notValidUrl = "jdbc:postgresql://4.4.4.4/"; - File dblinkFile = resourcesRepoDirectory.resolve(".dbgit").resolve(".dblink").toFile(); + File dblinkFile = RESOURCES_REPO_DIR.resolve(".dbgit").resolve(".dblink").toFile(); dblinkFile.delete(); // DriverManager.setLoginTimeout(3); // cmd.execute(getLinkCommandLine(notValidUrl, null, null)); // assertFalse(dblinkFile.exists(), "'.dblink file not created on non-valid url'"); - cmd.execute(getLinkCommandLine(pgTestDbUrl, pgTestDbUser, pgTestDbPass)); + cmd.execute(getLinkCommandLine(TEST_DB_URL, TEST_DB_USER, TEST_DB_PASS)); assertTrue(dblinkFile.exists()); } @Test - @Order(3) public void CmdCheckout() throws Exception { - boolean isNoDb = true; + + printMethodHead("CmdCheckout", "init"); + boolean isNoDb = true ; boolean isRestore = false; boolean isCreateBranch = false; boolean isUpgrade = false; + boolean isNoOwner = true; + String scriptPath = RESOURCES_REPO_DIR.resolve("checkout-r.sql").toAbsolutePath().toString(); + File scriptFile = new File(scriptPath); + scriptFile.delete(); GitMetaDataManager.getInstance().loadDBMetaData(); - for(String commitNumber : commitNumbers){ - dbgitCheckout(repoBranch, commitNumber, isNoDb, isRestore, isCreateBranch, isUpgrade); - } - - assertDoesNotThrow( () ->dbgitCheckout(repoBranch, commitNumbers.get(0), false, true, isCreateBranch, isUpgrade) ); - } - @Test - @Order(4) - public void CmdReset() throws Exception { - - File dblinkFile = resourcesRepoDirectory.resolve(".dbgit").resolve(".dblink").toFile(); - List modes = Arrays.asList("soft", "mixed", "hard", "merge", "keep"); - - dblinkFile.delete(); - assertFalse(dblinkFile.exists()); - - dbgitReset("hard"); - assertTrue(dblinkFile.exists()); + printMethodHead("CmdCheckout", "just checkout to first commit (-nodb)"); + dbgitCheckout(REPO_BRANCH, REPO_COMMIT_NUMBERS.get(0), isNoDb, isRestore, isCreateBranch, isUpgrade, isNoOwner); + printMethodHead("CmdCheckout", "try with restore to first commit (-r)"); + dbgitCheckout(REPO_BRANCH, REPO_COMMIT_NUMBERS.get(0), false, true, isCreateBranch, isUpgrade, isNoOwner); + printMethodHead("CmdCheckout", "try with restore to last commit (-s ...)" ); + assertDoesNotThrow( () -> + dbgitCheckout( + REPO_BRANCH, REPO_COMMIT_NUMBERS.get(REPO_COMMIT_NUMBERS.size() - 1), scriptPath, + false, false, isCreateBranch, isUpgrade, !TO_CREATE_CATALOG + ) + ); + assertTrue(scriptFile.exists()); + assertTrue(FileUtils.readFileToString(scriptFile).length() > 100); } @Test - @Order(5) public void CmdRestore() throws Exception { + boolean isRestore = false; boolean isToMakeBackup = true; boolean isNoDb = true; @@ -191,25 +152,33 @@ public void CmdRestore() throws Exception { dbgitReset("hard"); setToMakeBackup(isToMakeBackup); - for(String commitNumber : commitNumbers){ - String scriptPath = resourcesRepoDirectory.resolve("restore#"+commitNumber+".sql").toAbsolutePath().toString(); - File scriptFile = new File(scriptPath); + for(String commitNumber : REPO_COMMIT_NUMBERS){ + printMethodHead("CmdRestore", String.valueOf(REPO_COMMIT_NUMBERS.indexOf(commitNumber)) ); + + String scriptPath = RESOURCES_REPO_DIR.resolve(MessageFormat.format( + "restore#{0}.sql", + REPO_COMMIT_NUMBERS.indexOf(commitNumber) + )).toAbsolutePath().toString(); + String scriptPathA = scriptPath+"-again"; + File scriptFile = new File(scriptPath); + File scriptFileA = new File(scriptPathA); scriptFile.delete(); - ConsoleWriter.printlnGreen("\nDoing checkout:"); - dbgitCheckout(repoBranch, commitNumber, isNoDb, isRestore, isCreateBranch, isUpgrade, scriptPath); - dbgitCheckoutLs(); + dbgitCheckout(REPO_BRANCH, commitNumber, scriptPath, isNoDb, isRestore, isCreateBranch, isUpgrade, !TO_CREATE_CATALOG); + ConsoleWriter.printlnGreen(MessageFormat.format( + "\tIndex of commit in list: [{0}]", REPO_COMMIT_NUMBERS.indexOf(commitNumber) + ), messageLevel + ); -// ConsoleWriter.printlnGreen(MessageFormat.format("++ checkout: {0} symbols, path:\n{1}", -// scriptFile.exists() ? FileUtils.readFileToString(scriptFile).length() : 0, -// scriptPath -// )); scriptFile.delete(); dbgitRestore(true, true, scriptPath); + scriptFileA.delete(); + dbgitRestore(false, true, scriptPathA); + ConsoleWriter.printLineBreak(); //TODO assert sizes have no difference ConsoleWriter.printlnGreen(MessageFormat.format( "File 1st: {0} syms.\nFile 2nd: {1} syms.", @@ -220,18 +189,21 @@ public void CmdRestore() throws Exception { } @Test - @Order(6) public void CmdAdd() throws Exception { + printMethodHead("CmdAdd", null); + CmdAdd cmd = new CmdAdd(); // checkout to last commit - restore files and database // checkout 1st commit - restore files, index // call cmdAdd // ensure files added (what files?) - from last commit db state - String firstCommit = commitNumbers.get(0); - String lastCommit = commitNumbers.get(commitNumbers.size()-1); + String firstCommit = REPO_COMMIT_NUMBERS.get(0); + String lastCommit = REPO_COMMIT_NUMBERS.get(REPO_COMMIT_NUMBERS.size()-1); + + dbgitCheckout(REPO_BRANCH, lastCommit, false, true, false, false, false); + dbgitCheckout(REPO_BRANCH, firstCommit, true, false, false, false, false); - dbgitCheckout(repoBranch, lastCommit, false, true, false, false); IMapMetaObject fileImos = GitMetaDataManager.getInstance().loadFileMetaData(); IMapMetaObject databaseImos = GitMetaDataManager.getInstance().loadDBMetaData(); @@ -239,25 +211,81 @@ public void CmdAdd() throws Exception { ConsoleWriter.detailsPrintln("Find file to db object difference: ", messageLevel); MapDifference diffs = Maps.difference(fileImos, databaseImos); - ConsoleWriter.detailsPrintLn("Diffs: "); - diffs.entriesDiffering().forEach( (key, value) -> { - ConsoleWriter.detailsPrintLn(MessageFormat.format("{0} -> ({1}, {2})", - key, value.leftValue(), value.rightValue())); + diffs.entriesDiffering().forEach( (metaKey, metaObject) -> { + ConsoleWriter.detailsPrintlnGreen(metaKey, messageLevel+1); + + Map fileImoMap = metaObject.leftValue().toMap(); + Map dbImoMap = metaObject.rightValue().toMap(); + printMapsDifference(dbImoMap, fileImoMap, messageLevel+1); + }); + } + + //TODO вынести в отдельный метод с параметрами + //@Test + public void CmdClone() throws Exception { + printMethodHead("CmdClone", null); + + FileUtils.cleanDirectory(RESOURCES_REPO_DIR.toFile()); + //TODO кстати, вот он + dbgitClone(REPO_URL, String.valueOf(RESOURCES_REPO_DIR)); + configureDBConnection(); + + + File gitFile = RESOURCES_REPO_DIR.resolve(".git").toFile(); + File dbgitFile = RESOURCES_REPO_DIR.resolve(".dbgit").toFile(); + File[] dbgitFiles = dbgitFile.listFiles(); + + assertTrue(gitFile.exists(), "'.git folder exists'"); + assertTrue(dbgitFile.exists(), "'.dbgit folder exists'"); + assertTrue(dbgitFiles != null && dbgitFiles.length > 0, "'.dbgit folder is not empty'"); + + ConsoleWriter.printlnGreen(MessageFormat.format("Number of files in .dbgit {0}", dbgitFiles.length ), messageLevel); + Arrays.asList(dbgitFiles).forEach(x->ConsoleWriter.printlnRed(x.getPath(), messageLevel+1)); } + //@Test + public void CmdReset() throws Exception { + printMethodHead("CmdReset", null); + + dbgitCheckout(REPO_BRANCH, REPO_COMMIT_NUMBERS.get(0), true, false, false, false, false); + + File dblinkFile = RESOURCES_REPO_DIR.resolve(".dbgit").resolve(".dblink").toFile(); + List modes = Arrays.asList("soft", "mixed", "hard", "merge", "keep"); + + dblinkFile.delete(); + assertFalse(dblinkFile.exists()); + + dbgitReset("hard"); + assertTrue(dblinkFile.exists()); + + } private static void dbgitClone(String urlFrom, String dirTo) throws Exception { CmdClone cmdClone = new CmdClone(); + StringBuilder sb = new StringBuilder(); + Option directoryOption = Option.builder().longOpt("directory").hasArg(true).numberOfArgs(1).build(); directoryOption.getValuesList().add(dirTo); - CommandLine cmdLineClone = new CommandLine.Builder().addArg(urlFrom).addOption(directoryOption).build(); + + CommandLine cmdLineClone = new CommandLine.Builder() + .addArg(urlFrom) + .addOption(directoryOption).build(); + + sb.append(urlFrom + " "); + sb.append("-directory " + dirTo); + + ConsoleWriter.printlnGreen(MessageFormat.format("(call) dbgit {0} {1}", "clone", sb.toString()), messageLevel); + cmdClone.execute(cmdLineClone); } private static void dbgitReset(String mode) throws Exception { + StringBuilder sb = new StringBuilder(); + sb.append(mode); + CmdReset cmd = new CmdReset(); Option optionMode = new Option(mode , false, mode); CommandLine.Builder builder = new CommandLine.Builder(); @@ -266,16 +294,26 @@ private static void dbgitReset(String mode) throws Exception { cmd.execute(builder.addOption(optionMode).build()); } - private static void dbgitCheckout(String branchName, String commitNumber, boolean isNoDb, boolean isRestore, boolean isCreateBranch, boolean isUpgrade) throws Exception { - dbgitCheckout(branchName, commitNumber, isNoDb, isRestore, isCreateBranch, isUpgrade, null); + private static void dbgitCheckout(String branchName, String commitNumber, + boolean isNoDb, boolean isRestore, boolean isCreateBranch, + boolean isUpgrade, boolean isNoOwner) throws Exception { + dbgitCheckout(branchName, commitNumber, null, + isNoDb, isRestore, isCreateBranch, + isUpgrade, isNoOwner + ); } - private static void dbgitCheckout(String branchName, String commitNumber, boolean isNoDb, boolean isRestore, boolean isCreateBranch, boolean isUpgrade, String scriptPath + private static void dbgitCheckout(String branchName, String commitNumber, String scriptPath, + boolean isNoDb, boolean isRestore, boolean isCreateBranch, + boolean isUpgrade, boolean isNoOwner ) throws Exception { CmdCheckout cmd = new CmdCheckout(); CommandLine.Builder builder = new CommandLine.Builder(); + StringBuilder sb = new StringBuilder(); + String actualBranchName = branchName == null ? "master" : branchName; Option nodbOption = Option.builder("nodb").hasArg(false).build(); + Option noOwnerOption = Option.builder("noowner").hasArg(false).build(); Option restoreOption = Option.builder("r").hasArg(false).build(); Option newBranchOption = Option.builder("b").hasArg(false).build(); Option upgradeOption = Option.builder("u").hasArg(false).build(); @@ -284,23 +322,37 @@ private static void dbgitCheckout(String branchName, String commitNumber, boolea builder.addArg(actualBranchName); if(commitNumber != null){ builder.addArg(commitNumber); + sb.append(commitNumber + " "); } if(isNoDb){ builder.addOption(nodbOption); + sb.append("-nodb "); } if(isRestore){ builder.addOption(restoreOption); + sb.append("-r "); } if(isCreateBranch){ builder.addOption(newBranchOption); + sb.append("-b "); } if(isUpgrade){ builder.addOption(upgradeOption); + sb.append("-u "); + } + if(isNoOwner){ + builder.addOption(noOwnerOption); + sb.append("-noowner "); + } if(scriptPath != null){ scriptOption.getValuesList().add(scriptPath); builder.addOption(scriptOption); + sb.append("-s ").append(scriptPath).append(" "); } + builder.addOption(Option.builder("v").hasArg(false).build()); + ConsoleWriter.println(MessageFormat.format("(call) dbgit {0} {1}", "checkout", sb.toString()), messageLevel); + cmd.execute(builder.build()); } @@ -312,82 +364,128 @@ private static void dbgitCheckoutLs() throws Exception { Option lsOption = Option.builder("ls").hasArg(false).build(); builder.addOption(lsOption); + ConsoleWriter.println(MessageFormat.format("(call) dbgit {0}", "checkout -ls"), messageLevel); cmd.execute(builder.build()); } private static void dbgitRestore(boolean isRestore, boolean isToMakeBackup, String scriptPath) throws Exception { + CmdRestore cmd = new CmdRestore(); CommandLine.Builder builder = new CommandLine.Builder(); + StringBuilder sb = new StringBuilder(); + builder.addOption(Option.builder("v").hasArg(false).build()); + sb.append("-v "); if(isRestore){ Option restoreOption = Option.builder("r").hasArg(false).build(); builder.addOption(restoreOption); + sb.append("-r "); + } + if(!TO_CREATE_CATALOG){ + Option noownerOption = Option.builder("noowner").hasArg(false).build(); + builder.addOption(noownerOption); + sb.append("-noowner "); } if(scriptPath != null){ Option scriptOption = Option.builder("s").hasArg(true).numberOfArgs(1).build(); scriptOption.getValuesList().add(scriptPath); builder.addOption(scriptOption); + sb.append("-s ").append(scriptPath); } ConsoleWriter.println(MessageFormat.format("(call) dbgit {0} {1}", "checkout", sb.toString()), messageLevel); setToMakeBackup(isToMakeBackup); - cmd.execute(builder.build()); } - private static void configureTestDb(boolean eraseDatabase) throws Exception { + private static void configureTestDb(boolean tryCreateCatalog) throws Exception { + Properties testDbProps = new Properties(); + String propDbUrl = System.getProperty("pgTestDbUrl"); String propDbUser = System.getProperty("pgTestDbUser"); String propDbPass = System.getProperty("pgTestDbPass"); ConsoleWriter.println("(config) Using test database: ", messageLevel); if(propDbUrl != null){ - ConsoleWriter.printlnGreen(MessageFormat.format("Overriding DBConnection url from props: {0}", pgTestDbUrl)); - pgTestDbUrl = propDbUrl; - pgTestDbUser = propDbUser; - pgTestDbPass = propDbPass; + ConsoleWriter.print(" "); + TEST_DB_URL = propDbUrl; + TEST_DB_USER = propDbUser; + TEST_DB_PASS = propDbPass; } else { - ConsoleWriter.printlnGreen(MessageFormat.format("Using defaults DBConnection url: {0}", pgTestDbUrl)); + ConsoleWriter.print(" "); } - if(pgTestDbUser != null && pgTestDbPass != null){ - pgTestDbProps.put("user", pgTestDbUser); - pgTestDbProps.put("password", pgTestDbPass); + ConsoleWriter.print(TEST_DB_URL); + + if(TEST_DB_USER != null && TEST_DB_PASS != null){ + testDbProps.put("user", TEST_DB_USER); + testDbProps.put("password", TEST_DB_PASS); } - try (Connection conn = DriverManager.getConnection(pgTestDbUrl, pgTestDbProps)) { - if(eraseDatabase){ + if(tryCreateCatalog){ + try (Connection conn = DriverManager.getConnection(TEST_DB_URL, testDbProps)) { + if (!conn.getCatalog().isEmpty()) { - throw new Exception("Catalog must not be specified to create test database."); + throw new Exception("Catalog must not be specified to create test catalog."); } - IDBAdapter adapter = AdapterFactory.createAdapter(); + IDBAdapter adapter = AdapterFactory.createAdapter(conn); try(Statement stmt = conn.createStatement()){ stmt.execute(MessageFormat.format( - "DROP DATABASE {0}; ", - AdapterFactory.createAdapter().escapeNameIfNeeded(pgTestDbCatalog) + "DROP DATABASE \"{0}\"'; ", + adapter.escapeNameIfNeeded(TEST_DB_CATALOG) )); - } catch (Exception ex){ ConsoleWriter.println("### failed to drop database: " + ex.getLocalizedMessage()); } + } catch (Exception ex){ + ConsoleWriter.println( + "(config) failed to drop database: " + ex.getMessage().replaceAll("\n", ";") + , messageLevel + ); + } try(Statement stmt = conn.createStatement()){ stmt.execute(MessageFormat.format( - "CREATE DATABASE {0} ENCODING = 'UTF8'", - adapter.escapeNameIfNeeded(pgTestDbCatalog) + "CREATE DATABASE \"{0}\"; ", + adapter.escapeNameIfNeeded(TEST_DB_CATALOG) )); } catch (Exception ex){ - ConsoleWriter.println("### failed to create database: " + ex.getLocalizedMessage()); - throw ex; + ConsoleWriter.println( + "(config) failed to create database: " + ex.getMessage().replaceAll("\n", ";") + , messageLevel + ); + //throw ex; } - addCatalogToUrl(); } - } + addCatalogToUrl(); + + + DBConnection.createFileDBLink(TEST_DB_URL, testDbProps, false); + + } + + private static void configureDBConnection() throws Exception { + String dbLinkUrl = DBConnection.loadFileDBLink(new Properties()); + + if( !DBConnection.hasInstance() || + !DBConnection.getInstance().getConnect().getMetaData().getURL().equals(TEST_DB_URL)){ - DBConnection.createFileDBLink(pgTestDbUrl, pgTestDbProps, false); - pgTestDbConnection = DBConnection.getInstance(true); + new CmdLink().execute(getLinkCommandLine(TEST_DB_URL, TEST_DB_USER, TEST_DB_PASS)); + if(DBConnection.hasInstance()) { + DBConnection.getInstance().flushConnection(); + DBConnection.getInstance(); + } + + ConsoleWriter.printlnGreen(MessageFormat.format( + "(config) Set up DBConnection and ''.dblink'' state, \n\twas\t: {0} \n\tset\t: {1}" + , dbLinkUrl + , DBConnection.getInstance().getConnect().getMetaData().getURL() + ), messageLevel); + } + //not to broke any other database + assertEquals(TEST_DB_URL, DBConnection.getInstance().getConnect().getMetaData().getURL(), "DBConnection url IS NOT equal to test database url" ); } private static void loadCommitNumbersFromRepo() throws GitAPIException, IOException { @@ -395,30 +493,16 @@ private static void loadCommitNumbersFromRepo() throws GitAPIException, IOExcept InMemoryRepository repo = new InMemoryRepository(repoDesc); Git git = new Git(repo); git.fetch() - .setRemote(repoUrl) - .setRefSpecs(new RefSpec("+refs/heads/"+repoBranch+":refs/heads/"+repoBranch)) - .call(); + .setRemote(REPO_URL) + .setRefSpecs(new RefSpec("+refs/heads/"+ REPO_BRANCH +":refs/heads/"+ REPO_BRANCH)) + .call(); - String treeName = "refs/heads/"+repoBranch; // tag or branch + String treeName = "refs/heads/"+ REPO_BRANCH; // tag or branch for (RevCommit commit : git.log().add(repo.resolve(treeName)).call()) { - commitNumbers.add(commit.getName()); + REPO_COMMIT_NUMBERS.add(commit.getName()); } } - private static void restoreDbLinkIfNeeded() throws Exception { - String urlWas = DBConnection.loadFileDBLink(new Properties()); - if(pgTestDbConnection == null || !urlWas.equals(pgTestDbUrl)){ - new CmdLink().execute(getLinkCommandLine(pgTestDbUrl, pgTestDbUser, pgTestDbPass)); - pgTestDbConnection = DBConnection.getInstance(); - - ConsoleWriter.printlnGreen(MessageFormat.format( - "+ .dblink restored, \nwas: {0}, \nnow: {1}" - , urlWas, ((PgConnection) pgTestDbConnection.getConnect()).getURL() - )); - } - assertEquals(((PgConnection) pgTestDbConnection.getConnect()).getURL(), pgTestDbUrl); - } - private static void setToMakeBackup(boolean isToMakeBackup) throws Exception { String sectionName = "core"; String parameterName = "TO_MAKE_BACKUP"; @@ -444,5 +528,72 @@ private static CommandLine getLinkCommandLine(String url, String user, String pa return builder.build(); } + private static void printMethodHead(String name, String part){ + String text = name + ((part != null) ? " part '" + part + "'" : "") ; + int length = 92; + int textLength = text.length(); + boolean shouldAddSpace = textLength % 2 != length % 2; + int remSpaceLength = length - textLength - (shouldAddSpace ? 0 : 1); + int sideHeaderLength = remSpaceLength / 2; + StringBuilder sb = new StringBuilder(); + + for ( int step = 0; step < 2; step ++){ + if( step == 0 ) sb.append(text); + for (int i = sideHeaderLength; i > 0;){ + sb.append(" -"); i -= 2; + if( i == 2 ) { sb.append(" "); i--; } + if( i == 1 ) { sb.append("|\n") ; i--; } + } + + sb.reverse(); + } + + ConsoleWriter.printlnColor(sb.toString(), Ansi.FColor.MAGENTA, 0); + } + + private static void printMapsDifference(Map mapBefore, Map mapAfter, int level){ + + MapDifference difference = Maps.difference(mapBefore, mapAfter); + Map add = difference.entriesOnlyOnRight(); + Map remove = difference.entriesOnlyOnLeft(); + Map> change = difference.entriesDiffering(); + for (Map.Entry addEntry : add.entrySet()) { + ConsoleWriter.println(MessageFormat.format("+ ''{0}'': ", addEntry.getKey()), level); + printNode( addEntry.getValue(), level ); + } + + for (Map.Entry removeEntry : remove.entrySet()) { + ConsoleWriter.println(MessageFormat.format("- ''{0}'': ", removeEntry.getKey()), level); + //printNode( removeEntry.getValue(), level ); + } + + for (Map.Entry> changeEntry : change.entrySet()) { + ConsoleWriter.println(MessageFormat.format("* ''{0}'': ", changeEntry.getKey()), level); + + Object valueBefore = changeEntry.getValue().leftValue(); + Object valueAfter = changeEntry.getValue().rightValue(); + + if( valueBefore instanceof Map && valueAfter instanceof Map ){ + printMapsDifference((Map) valueBefore, (Map) valueAfter, level+1); + } else { + ConsoleWriter.print(MessageFormat.format("\"{0}\" -> \"{1}\"", valueBefore, valueAfter)); + } + + } + } + + private static void printNode(Object node, int level){ + if(node instanceof Map) { + Map map = (Map) node; + + for (Map.Entry entry : map.entrySet()) { + ConsoleWriter.println(MessageFormat.format("''{0}'': " ,entry.getKey()), level+1); + printNode( entry.getValue(), level+1); + } + } + else { + ConsoleWriter.print(node != null ? node : ""); + } + } } diff --git a/src/test/java/ru/fusionsoft/dbgit/MetaObjectTest.java b/src/test/java/ru/fusionsoft/dbgit/MetaObjectTest.java index 9251afd..b5fae39 100644 --- a/src/test/java/ru/fusionsoft/dbgit/MetaObjectTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/MetaObjectTest.java @@ -108,28 +108,28 @@ public void testMetaTable() { */ - public void testMetaShema() throws Exception { - DBSchema sh = new DBSchema("myshema"); - StringProperties pr = sh.getOptions(); - pr.setData("info value"); - pr.addChild("param1", "val1"); - pr.addChild("param2", "val2"); - pr.addChild("param3", "val3"); - - StringProperties sub = pr.addChild("subparams"); - sub.addChild("subparam1", "asd1"); - sub.addChild("subparam2", "asd2"); - - MetaObjOptions meta = (MetaObjOptions)MetaObjectFactory.createMetaObject(DBGitMetaType.DBGitSchema); - meta.setObjectOption(sh); - - //assertEquals("Assert hash!", meta.getHash(), "5c376e1836f4cbc763808fe077a84f2eaf9cdb9dc7e22107fc44a9567f4cf264"); - - /* - System.out.println(meta.getHash()); - - System.out.println(pr.toString()); - */ - //TODO to yaml and assert - } +// public void testMetaShema() throws Exception { +// DBSchema sh = new DBSchema("myshema"); +// StringProperties pr = sh.getOptions(); +// pr.setData("info value"); +// pr.addChild("param1", "val1"); +// pr.addChild("param2", "val2"); +// pr.addChild("param3", "val3"); +// +// StringProperties sub = pr.addChild("subparams"); +// sub.addChild("subparam1", "asd1"); +// sub.addChild("subparam2", "asd2"); +// +// MetaObjOptions meta = (MetaObjOptions)MetaObjectFactory.createMetaObject(DBGitMetaType.DBGitSchema); +// meta.setObjectOption(sh); +// +// //assertEquals("Assert hash!", meta.getHash(), "5c376e1836f4cbc763808fe077a84f2eaf9cdb9dc7e22107fc44a9567f4cf264"); +// +// /* +// System.out.println(meta.getHash()); +// +// System.out.println(pr.toString()); +// */ +// //TODO to yaml and assert +// } } diff --git a/src/test/java/ru/fusionsoft/dbgit/UtilTest.java b/src/test/java/ru/fusionsoft/dbgit/UtilTest.java index 3f8cf80..405598a 100644 --- a/src/test/java/ru/fusionsoft/dbgit/UtilTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/UtilTest.java @@ -1,16 +1,14 @@ package ru.fusionsoft.dbgit; -import com.jcraft.jsch.jce.Random; -/* -import junit.framework.Test; -import junit.framework.TestCase; -import junit.framework.TestSuite; -*/ -import ru.fusionsoft.dbgit.dbobjects.DBTableField; +import org.junit.jupiter.api.*; +import static org.junit.jupiter.api.Assertions.*; -import ru.fusionsoft.dbgit.utils.MaskFilter; -public class UtilTest /*extends TestCase*/ { + + +public class UtilTest { + + @Test public void testMask() { /* MaskFilter mask = new MaskFilter("asd*.txt"); @@ -30,7 +28,7 @@ public void testMask() { assertFalse(mask.match("pat\\ws612df.txt")); */ } - + @Test public void testMapField() { /* IMapFields map = new TreeMapFields(); diff --git a/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java b/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java index cd2759c..0a7a0be 100644 --- a/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java @@ -3,28 +3,22 @@ import com.google.common.collect.Lists; import org.apache.commons.lang3.time.StopWatch; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - import ru.fusionsoft.dbgit.adapters.AdapterFactory; -import ru.fusionsoft.dbgit.adapters.IFactoryDBConvertAdapter; import ru.fusionsoft.dbgit.core.DBGitConfig; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.dbobjects.*; import ru.fusionsoft.dbgit.meta.*; -import ru.fusionsoft.dbgit.oracle.DBRestorePackageOracle; import ru.fusionsoft.dbgit.statement.StatementLogging; import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import javax.naming.Name; import java.sql.*; import java.text.MessageFormat; import java.util.*; - -import static org.junit.Assert.*; +import org.junit.jupiter.api.*; +import static org.junit.jupiter.api.Assertions.*; +@Tag("mssqlTest") public class DBAdapterMssqlTest { public static Properties testProps; @@ -39,11 +33,11 @@ public class DBAdapterMssqlTest { * Protocols -> SQL EXPRESS protocols -> Protocol -> IP adresses -> IPAll -> TCP Port to 1433 and Dynamic TCP Port to blank * */ - public static String TEST_CONN_URL = "localhost:1433"; - public static String TEST_CONN_CATALOG = "MyDiet"; + public static String TEST_CONN_URL = "23.105.226.179:1433"; + public static String TEST_CONN_CATALOG = "testdatabasegit"; public static String TEST_CONN_STRING = "jdbc:sqlserver://"+TEST_CONN_URL+";databaseName="+TEST_CONN_CATALOG+";integratedSecurity=false;"; - public static String TEST_CONN_USER = "test"; - public static String TEST_CONN_PASS = "test"; + public static String TEST_CONN_USER = "sa"; + public static String TEST_CONN_PASS = "s%G351as"; private static DBAdapterMssql testAdapter; private static DBBackupAdapterMssql testBackup; @@ -77,7 +71,7 @@ public class DBAdapterMssqlTest { private static int messageLevel = 0; - @Before + @BeforeEach public void setUp() throws Exception { if(!isInitialized){ try { @@ -94,12 +88,13 @@ public void setUp() throws Exception { catch (Exception ex){ fail(ex.getMessage()); } - dropBackupTables(); + dropBackupObjects(); } } - @After - public void tearDown() throws Exception { + @AfterEach + public void tearDown() throws Exception + { } @Test @@ -190,7 +185,7 @@ public void getTableFields() throws Exception{ Map fields = testAdapter.getTableFields(schema, name); assertEquals("sql_variant(0)", fields.get("col10").getTypeSQL()); - assertEquals("native", fields.get("col10").getTypeUniversal()); + assertEquals("native",fields.get("col10").getTypeUniversal().toString()); dropTable(schema + "." + name); } @@ -209,7 +204,7 @@ public void getTableData() { createTestTriggerProcedureFunctions(triggerTableName); DBTableData data = testAdapter.getTableData(testConnection.getSchema(), triggerTableName); - ResultSet rs = data.getResultSet(); + ResultSet rs = data.resultSet(); ResultSetMetaData md = rs.getMetaData(); int cols = md.getColumnCount(); rs.next(); @@ -223,7 +218,7 @@ public void getTableData() { System.out.println(watch.toString()); } catch (Exception ex) { - fail(ex.toString()); + fail(ex.getLocalizedMessage()); } } @@ -239,7 +234,7 @@ public void getTableDataPortion() { ); DBTableData data = testAdapter.getTableDataPortion("tempdb.", "#bigDummyTable", 2, 0); - ResultSet rs = data.getResultSet(); + ResultSet rs = data.resultSet(); while (rs.next()) rowsAffected++; @@ -629,6 +624,7 @@ public void backupMetaTable() throws Exception{ @Test public void backupMetaSql() throws Exception{ + dropBackupObjects(); createTestTriggerProcedureFunctions(triggerTableName); createTestView(schema, viewName); @@ -921,7 +917,7 @@ public void restoreTriggerAfterDrop() throws Exception { //heplers - public void dropBackupTables() throws Exception{ + public void dropBackupObjects() throws Exception{ Map tables = testAdapter.getTables(schema); for (DBTable table : tables.values()){ if(table.getName().startsWith("BACKUP$")){ @@ -929,8 +925,44 @@ public void dropBackupTables() throws Exception{ dropTable(schema+"."+table.getName()); } } + + Map views = testAdapter.getViews(schema); + for (DBView view : views.values()){ + if(view.getName().startsWith("BACKUP$")){ + ConsoleWriter.println("drop "+view.getName(), messageLevel); + dropView(schema+"."+view.getName()); + } + } + + Map Triggers = testAdapter.getTriggers(schema); + for (DBTrigger Trigger : Triggers.values()){ + if(Trigger.getName().startsWith("BACKUP$")){ + ConsoleWriter.println("drop "+Trigger.getName(), messageLevel); + dropTrigger(schema+"."+Trigger.getName()); + } + } + + Map Procedures = testAdapter.getProcedures(schema); + for (DBProcedure Procedure : Procedures.values()){ + if(Procedure.getName().startsWith("BACKUP$")){ + ConsoleWriter.println("drop "+Procedure.getName(), messageLevel); + dropProcedure(schema+"."+Procedure.getName()); + } + } + + Map Functions = testAdapter.getFunctions(schema); + for (DBFunction Function : Functions.values()){ + if(Function.getName().startsWith("BACKUP$")){ + ConsoleWriter.println("drop "+Function.getName(), messageLevel); + dropFunction(schema+"."+Function.getName()); + } + } + + } + + public boolean trySetMasterCatalog(){ try { if (!isMasterDatabase) { @@ -1079,6 +1111,42 @@ public void dropTable(String schemaAndName) throws Exception{ stmt.close(); } + public void dropView(String schemaAndName) throws Exception{ + Statement stmt = testConnection.createStatement(); + String name = convertSchemaAndName(schemaAndName); + String ddl = MessageFormat.format("IF OBJECT_ID(''{0}'', ''V'') IS NOT NULL DROP VIEW {0}", name); + stmt.execute(ddl); + stmt.close(); + } + + public void dropTrigger(String schemaAndName) throws Exception{ + Statement stmt = testConnection.createStatement(); + String name = convertSchemaAndName(schemaAndName); + String ddl = MessageFormat.format("IF OBJECT_ID(''{0}'', ''TR'') IS NOT NULL DROP TRIGGER {0}", name); + stmt.execute(ddl); + stmt.close(); + } + + public void dropProcedure(String schemaAndName) throws Exception{ + Statement stmt = testConnection.createStatement(); + String name = convertSchemaAndName(schemaAndName); + String ddl = MessageFormat.format("IF OBJECT_ID(''{0}'', ''P'') IS NOT NULL DROP PROCEDURE {0}", name); + stmt.execute(ddl); + stmt.close(); + } + + public void dropFunction(String schemaAndName) throws Exception{ + Statement stmt = testConnection.createStatement(); + String name = convertSchemaAndName(schemaAndName); + String ddl1 = MessageFormat.format("IF OBJECT_ID(''{0}'', ''FN'') IS NOT NULL DROP FUNCTION {0}", name); + String ddl2 = MessageFormat.format("IF OBJECT_ID(''{0}'', ''IF'') IS NOT NULL DROP FUNCTION {0}", name); + String ddl3 = MessageFormat.format("IF OBJECT_ID(''{0}'', ''TF'') IS NOT NULL DROP FUNCTION {0}", name); + stmt.execute(ddl1); + stmt.execute(ddl2); + stmt.execute(ddl3); + stmt.close(); + } + public String convertSchemaAndName(String san) { return san.startsWith("#") ? "tempdb.." + san.substring(1) diff --git a/src/test/resources/repo b/src/test/resources/repo index 4f3953d..8867384 160000 --- a/src/test/resources/repo +++ b/src/test/resources/repo @@ -1 +1 @@ -Subproject commit 4f3953d44743a539321d024871182eef8f1cd7f9 +Subproject commit 88673845e9891228d2ebb7ad3bdebb534ce8efbe From ba19b0c6897df5e72ca9905a5f1200a929b03a61 Mon Sep 17 00:00:00 2001 From: rocket Date: Thu, 13 May 2021 21:09:48 +0300 Subject: [PATCH 45/68] Introducing integration tests with beta developing IT framework integration\DbGitTest.java is actual integration tests and integration\ClassCompositonTest.java is some self test to IT framework Fix tests running via Maven Surefire plugin (ITests are now enabled by default), older and broken marked as @Tag("deprecated") Lots of minor fixes and refactoring to make codebase behaviour more predictable --- pom.xml | 15 +- .../fusionsoft/dbgit/command/CmdCheckout.java | 4 +- .../ru/fusionsoft/dbgit/command/CmdClone.java | 3 +- .../ru/fusionsoft/dbgit/command/CmdInit.java | 1 - .../ru/fusionsoft/dbgit/command/CmdLink.java | 3 +- .../fusionsoft/dbgit/command/CmdRestore.java | 7 +- .../ru/fusionsoft/dbgit/command/CmdRm.java | 10 +- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 117 +++-- .../ru/fusionsoft/dbgit/core/DBGitConfig.java | 4 +- .../core/ExceptionDBGitObjectNotFound.java | 2 +- .../dbgit/core/GitMetaDataManager.java | 11 +- .../fusionsoft/dbgit/core/db/FieldType.java | 4 +- .../ru/fusionsoft/dbgit/dbobjects/DBCode.java | 3 + .../dbgit/dbobjects/DBConstraint.java | 1 + .../dbgit/dbobjects/DBFunction.java | 2 +- .../fusionsoft/dbgit/dbobjects/DBIndex.java | 3 + .../fusionsoft/dbgit/dbobjects/DBPackage.java | 1 + .../dbgit/dbobjects/DBProcedure.java | 1 + .../dbgit/dbobjects/DBSQLObject.java | 7 +- .../dbgit/dbobjects/DBSchemaObject.java | 5 +- .../dbgit/dbobjects/DBSequence.java | 4 + .../fusionsoft/dbgit/dbobjects/DBTable.java | 12 +- .../dbgit/dbobjects/DBTableField.java | 143 +++--- .../fusionsoft/dbgit/dbobjects/DBTrigger.java | 1 + .../ru/fusionsoft/dbgit/dbobjects/DBView.java | 1 + .../ru/fusionsoft/dbgit/meta/MetaBase.java | 6 +- .../ru/fusionsoft/dbgit/meta/MetaSql.java | 3 +- .../ru/fusionsoft/dbgit/meta/MetaTable.java | 14 +- .../fusionsoft/dbgit/meta/MetaTableData.java | 2 +- .../dbgit/mssql/DBAdapterMssql.java | 7 +- .../dbgit/mssql/DBRestoreTableMssql.java | 2 +- .../dbgit/postgres/DBAdapterPostgres.java | 27 +- src/main/resources/lang/eng.yaml | 5 +- .../java/ru/fusionsoft/dbgit/DBGitTest.java | 17 +- .../ru/fusionsoft/dbgit/MetaObjectTest.java | 135 ------ .../java/ru/fusionsoft/dbgit/UtilTest.java | 61 --- .../integration/ClassCompositionTest.java | 200 ++++++++ .../dbgit/integration/DbGitTest.java | 434 ++++++++++++++++++ .../dbgit/integration/StickyFunctionTest.java | 31 ++ .../deprecated/PathAfterDbGitMainRun.java | 35 ++ .../deprecated/PathAfterExecutableRun.java | 88 ++++ .../deprecated/SystemUserDirPath.java | 10 + .../deprecated/WithDbGitMainRunScalar.java | 26 ++ .../dbgit/integration/primitives/Args.java | 5 + .../integration/primitives/Credentials.java | 6 + .../primitives/DescribedTestResult.java | 45 ++ .../integration/primitives/Function.java | 6 + .../integration/primitives/GrouppedTR.java | 34 ++ .../primitives/NullPrintStream.java | 14 + .../dbgit/integration/primitives/Patch.java | 8 + .../primitives/PatchSequental.java | 24 + .../integration/primitives/PatchedScalar.java | 17 + .../primitives/RunnableWithException.java | 5 + .../integration/primitives/SafeScalar.java | 5 + .../integration/primitives/SafeScalarOf.java | 25 + .../dbgit/integration/primitives/Scalar.java | 8 + .../integration/primitives/SimpleTest.java | 26 ++ .../primitives/SimpleTestResult.java | 29 ++ .../primitives/StickyFunction.java | 30 ++ .../integration/primitives/StickyScalar.java | 25 + .../dbgit/integration/primitives/Test.java | 6 + .../integration/primitives/TestResult.java | 6 + .../primitives/args/ArgsCheckoutNodb.java | 12 + .../primitives/args/ArgsDbGitAddRemote.java | 15 + .../primitives/args/ArgsExplicit.java | 13 + .../integration/primitives/args/ArgsLink.java | 32 ++ .../primitives/args/ArgsRunningCommand.java | 31 ++ .../primitives/args/ArgsWithAppend.java | 27 ++ .../primitives/args/ArgsWithPrepend.java | 26 ++ .../args/specific/AutoPgLinkArgs.java | 10 + .../args/specific/DedicatedPgLinkArgs.java | 27 ++ .../specific/GitTestRepoAddRemoteArgs.java | 21 + .../args/specific/LocalPgLinkArgs.java | 23 + .../chars/CharSequenceEnvelope.java | 54 +++ .../integration/primitives/chars/CharsOf.java | 15 + .../primitives/chars/CommitsFromRepo.java | 51 ++ .../chars/DbIgnoreDefaultChars.java | 21 + .../primitives/chars/DbLinkChars.java | 21 + .../primitives/chars/InputStreamChars.java | 41 ++ .../primitives/chars/SavedConsoleText.java | 69 +++ .../chars/TestResultDetailedChars.java | 44 ++ .../chars/TestResultShortChars.java | 16 + .../chars/TestSuccessMarkChars.java | 21 + .../credentials/CredentialsEnvelope.java | 25 + .../credentials/FromFileCredentials.java | 16 + .../FromPropertiesCredentials.java | 14 + .../credentials/SimpleCredentials.java | 24 + .../specific/GitTestRepoCredentials.java | 25 + .../specific/GitTestRepoFileCredentials.java | 10 + .../specific/GitTestRepoPropsCredentials.java | 9 + .../credentials/specific/PgCredentials.java | 25 + .../specific/PgFileCredentials.java | 10 + .../specific/PgPropsCredentials.java | 9 + .../primitives/files/DbGitMetaFiles.java | 47 ++ .../primitives/files/FileContent.java | 43 ++ .../primitives/files/TextFileTest.java | 56 +++ .../primitives/files/TextResource.java | 11 + .../primitives/files/TextResourceGroup.java | 11 + .../patch/PathPatchCloningGitRepo.java | 42 ++ .../patch/PathPatchConfiguringDbGit.java | 18 + .../patch/PathPatchCreatingFile.java | 23 + .../patch/PathPatchDeletingFiles.java | 30 ++ .../patch/PathPatchDeletingFilesWildcard.java | 26 ++ .../patch/PathPatchRunningDbGitFrom.java | 46 ++ .../patch/PathPatchRunningProcessFrom.java | 86 ++++ .../primitives/path/PathAfterCommandRun.java | 24 + .../path/PathAfterDbGitRestore.java | 42 ++ .../primitives/path/PathAfterDbGitRun.java | 48 ++ .../primitives/path/PathEnvelope.java | 160 +++++++ .../primitives/path/PathNotProjectRoot.java | 30 ++ .../integration/primitives/path/PathOf.java | 15 + .../path/PathOfBuiltDbGitExecutable.java | 12 + .../primitives/path/PathPatched.java | 14 + .../primitives/path/PathPrintsToConsole.java | 26 ++ .../primitives/path/PathRelativeTo.java | 21 + ...athWithBuildingDbGitExecutableFromGit.java | 59 +++ .../path/PathWithDbGitCheckoutAndLink.java | 33 ++ .../path/PathWithDbGitRepoInitialized.java | 29 ++ .../primitives/path/PathWithFiles.java | 22 + .../primitives/path/PathWithoutFiles.java | 26 ++ .../specific/CurrentWorkingDirectory.java | 12 + ...rojectTestResourcesCleanDirectoryPath.java | 32 ++ .../dbgit/mssql/DBAdapterMssqlTest.java | 5 +- src/test/resources/repo | 1 - 124 files changed, 3232 insertions(+), 367 deletions(-) delete mode 100644 src/test/java/ru/fusionsoft/dbgit/MetaObjectTest.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/UtilTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/ClassCompositionTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/DbGitTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/StickyFunctionTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterDbGitMainRun.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterExecutableRun.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/deprecated/SystemUserDirPath.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/deprecated/WithDbGitMainRunScalar.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/Args.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/Credentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/DescribedTestResult.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/Function.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/GrouppedTR.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/NullPrintStream.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/Patch.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequental.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchedScalar.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/RunnableWithException.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalar.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalarOf.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/Scalar.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTestResult.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyFunction.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyScalar.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/Test.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/TestResult.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsCheckoutNodb.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsDbGitAddRemote.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsExplicit.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsLink.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsWithAppend.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsWithPrepend.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/DedicatedPgLinkArgs.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/GitTestRepoAddRemoteArgs.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/LocalPgLinkArgs.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharSequenceEnvelope.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOf.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CommitsFromRepo.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbIgnoreDefaultChars.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbLinkChars.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/InputStreamChars.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/SavedConsoleText.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultDetailedChars.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultShortChars.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestSuccessMarkChars.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsEnvelope.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromFileCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromPropertiesCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/SimpleCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoFileCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoPropsCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgFileCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgPropsCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/DbGitMetaFiles.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/FileContent.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextFileTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextResource.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextResourceGroup.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCloningGitRepo.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchConfiguringDbGit.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCreatingFile.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchDeletingFiles.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchDeletingFilesWildcard.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGitFrom.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterCommandRun.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRestore.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRun.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathEnvelope.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathNotProjectRoot.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOf.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOfBuiltDbGitExecutable.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPatched.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPrintsToConsole.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathRelativeTo.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithBuildingDbGitExecutableFromGit.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitCheckoutAndLink.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitRepoInitialized.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithFiles.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithoutFiles.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/CurrentWorkingDirectory.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/ProjectTestResourcesCleanDirectoryPath.java delete mode 160000 src/test/resources/repo diff --git a/pom.xml b/pom.xml index da1f504..4c26c60 100644 --- a/pom.xml +++ b/pom.xml @@ -8,14 +8,13 @@ jar - org.apache.maven.plugins maven-surefire-plugin 3.0.0-M5 - - + none() | integration + deprecated @@ -84,6 +83,16 @@ + + + false + ${project.basedir}/src/main/resources + + logback-test.xml + + + + ${project.basedir}/src/main/resources/ diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java index d2573d7..32f3245 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java @@ -63,14 +63,14 @@ public void execute(CommandLine cmdLine) throws Exception { String headName = head.getName(); String message = walk.parseCommit(head.getObjectId()).getShortMessage(); - ConsoleWriter.printlnGreen(DBGitLang.getInstance() + System.out.println(DBGitLang.getInstance() .getValue("general", "checkout", "printBranchAndCommit") .withParams( !branch.equals(headNumber) ? branch + ": " + headName : headNumber, headName, message ) - , messageLevel +// , messageLevel ); } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdClone.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdClone.java index 2d6b383..85a161d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdClone.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdClone.java @@ -13,7 +13,8 @@ public class CmdClone implements IDBGitCommand { private Options opts = new Options(); public CmdClone() { - opts.addOption("directory", false, "subdirectory to clone into"/*getLang().getValue("help", "commit-a").toString()*/); + opts.addOption("directory", true, "subdirectory to clone into"/*getLang + ().getValue("help", "commit-a").toString()*/); } @Override diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdInit.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdInit.java index 8aace6b..f57e10c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdInit.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdInit.java @@ -42,7 +42,6 @@ public void execute(CommandLine cmdLine) throws Exception { } DBGit.gitInit(dir); - } } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java index bac371f..272ccda 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java @@ -46,7 +46,8 @@ public void execute(CommandLine cmdLine) throws Exception { DBConnection conn = DBConnection.getInstance(false); if(cmdLine.hasOption("ls")) { - ConsoleWriter.printlnGreen(DBConnection.loadFileDBLink(new Properties()), messageLevel); +// ConsoleWriter.printlnGreen(DBConnection.loadFileDBLink(new Properties()), messageLevel); + System.out.println(DBConnection.loadFileDBLink(new Properties())); return; } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java index a16e63f..6ac8a42 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java @@ -200,14 +200,11 @@ private boolean checkNeedsRestore(IMetaObject obj){ boolean isRestore = false; try { IMetaObject dbObj = IMetaObject.create(obj.getName()); - GitMetaDataManager.getInstance().loadFromDB(dbObj); - isRestore = !dbObj.getHash().equals(obj.getHash()); + final boolean exists = GitMetaDataManager.getInstance().loadFromDB(dbObj); + isRestore = !exists || !dbObj.getHash().equals(obj.getHash()); } catch (ExceptionDBGit e) { isRestore = true; e.printStackTrace(); - } catch (ExceptionDBGitRunTime e) { - isRestore = true; - e.printStackTrace(); } return isRestore; } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java index 9844ccf..3855497 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRm.java @@ -96,7 +96,15 @@ public void execute(CommandLine cmdLine) throws Exception { } if (forgetImmediately) { ConsoleWriter.detailsPrintln(getLang().getValue("general", "rm", "removingFromIndex"), messageLevel+1); - index.getTreeItems().values().stream().filter(ItemIndex::getIsDelete).collect(Collectors.toList()).forEach(x->index.getTreeItems().remove(x.getName())); + index.getTreeItems().values() + .stream() + .filter(ItemIndex::getIsDelete) + .collect(Collectors.toList()) + .forEach( + x->index.getTreeItems() + .remove(x.getName()) + ); + index.saveDBIndex(); index.addToGit(); ConsoleWriter.detailsPrintGreen(getLang().getValue("general", "ok")); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index b245496..0c70fbf 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -2,6 +2,8 @@ import java.io.File; import java.io.IOException; +import java.nio.file.Path; +import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; import java.util.Set; @@ -38,8 +40,12 @@ private DBGit() { try { FileRepositoryBuilder builder = new FileRepositoryBuilder(); repository = builder - .readEnvironment() // scan environment GIT_* variables - .findGitDir() // scan up the file system tree + .setGitDir( + Paths.get("") + .resolve(".git") + .toAbsolutePath() + .toFile() + ) .build(); git = new Git(repository); @@ -86,8 +92,8 @@ public static void initUrlInstance(String gitDirUrl, boolean force) { } instance.repository.close(); instance.git.close(); - instance = new DBGit(gitDirUrl); } + instance = new DBGit(gitDirUrl); } public static boolean repositoryExists() { @@ -375,45 +381,67 @@ public void gitPush(String remoteName) throws ExceptionDBGit { , messageLevel+1 ); - Iterable result = git.push() - .setCredentialsProvider(getCredentialsProviderByName(remoteName.equals("") ? Constants.DEFAULT_REMOTE_NAME : remoteName)) - .setRemote(remoteName.equals("") ? Constants.DEFAULT_REMOTE_NAME : remoteName).call(); - - ConsoleWriter.detailsPrintln("Push called ", messageLevel); - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("general", "push", "called") - , messageLevel+1 - ); - - result.forEach(pushResult -> { - if (pushResult == null){ - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("general", "push", "nullResult") - , 1 - ); - } else { - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("general", "push", "callResult") - .withParams(pushResult.toString()) - , messageLevel+1 - ); - } - for (RemoteRefUpdate res : pushResult.getRemoteUpdates()) { - if (res.getStatus() == RemoteRefUpdate.Status.UP_TO_DATE){ + try { + + Iterable result = git + .push() + .setCredentialsProvider( + getCredentialsProviderByName( + remoteName.equals("") + ? Constants.DEFAULT_REMOTE_NAME + : remoteName + ) + ) + .setRemote( + remoteName.equals("") + ? Constants.DEFAULT_REMOTE_NAME + : remoteName + ) + .call(); + + + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "called") + , messageLevel+1 + ); + + result.forEach(pushResult -> { + if (pushResult == null){ ConsoleWriter.println(DBGitLang.getInstance() - .getValue("general", "push", "upToDate") + .getValue("general", "push", "nullResult") , 1 ); - } - else { + } else { ConsoleWriter.println(DBGitLang.getInstance() - .getValue("general", "push", "result") - .withParams(res.toString()) - , 1 + .getValue("general", "push", "callResult") + .withParams(pushResult.toString()) + , messageLevel+1 ); } - } - }); + for (RemoteRefUpdate res : pushResult.getRemoteUpdates()) { + if (res.getStatus() == RemoteRefUpdate.Status.UP_TO_DATE){ + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "upToDate") + , 1 + ); + } + else { + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "result") + .withParams(res.toString()) + , 1 + ); + } + } + }); + + } catch (Exception ex) { + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("general", "push", "callResult") + .withParams(ex.getLocalizedMessage()) + , messageLevel + 1 + ); + } } catch (Exception e) { throw new ExceptionDBGit(e); @@ -451,7 +479,9 @@ public static void gitClone(String link, String remoteName, File directory) thro .setCredentialsProvider(cp) .setDirectory(directory); - cc.call(); + final Git call = cc.call(); + call.getRepository().close(); + call.close(); ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "clone", "cloned"), messageLevel); @@ -474,6 +504,7 @@ public void gitRemote(String command, String name, String uri) throws ExceptionD remote.setName(name); remote.setUri(new URIish(uri)); remote.call(); + remote.getRepository().close(); ConsoleWriter.printlnGreen(DBGitLang.getInstance().getValue("general", "remote", "added"), messageLevel); @@ -484,6 +515,7 @@ public void gitRemote(String command, String name, String uri) throws ExceptionD RemoteRemoveCommand remote = git.remoteRemove(); remote.setName(name); remote.call(); + remote.getRepository().close(); ConsoleWriter.printlnGreen(DBGitLang.getInstance().getValue("general", "remote", "removed"), messageLevel); @@ -512,8 +544,14 @@ public void gitReset(String mode) throws ExceptionDBGit { public void gitFetch(String remote) throws ExceptionDBGit { try { - FetchCommand fetch = git.fetch() - .setCredentialsProvider(getCredentialsProviderByName(remote.equals("") ? Constants.DEFAULT_REMOTE_NAME : remote)); + FetchCommand fetch = git + .fetch() + .setCredentialsProvider(getCredentialsProviderByName( + remote.equals("") + ? Constants.DEFAULT_REMOTE_NAME + : remote + ) + ); if (remote.length() > 0) fetch = fetch.setRemote(remote); @@ -521,6 +559,7 @@ public void gitFetch(String remote) throws ExceptionDBGit { fetch = fetch.setRemote(Constants.DEFAULT_REMOTE_NAME); fetch.call(); + fetch.getRepository().close(); ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "done"), messageLevel); } catch (Exception e) { diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java index 2b2eb0f..d3b79bc 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java @@ -136,7 +136,7 @@ public void setValueGlobal(String parameter, String value) throws ExceptionDBGit public void setValue(String parameter, String value, boolean global) throws ExceptionDBGit { try { if (global) { - if (!iniGlobal.get("core").containsKey(parameter)) + if (!iniGlobal.get("core").containsKey(parameter) && !parameter.equals("CURRENT_OBJECT")) ConsoleWriter.detailsPrintln( DBGitLang.getInstance().getValue("errors", "config", "noParameter").withParams(parameter) , messageLevel @@ -149,7 +149,7 @@ public void setValue(String parameter, String value, boolean global) throws Exce if (getIni() == null) throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "gitRepNotFound")); - if (!ini.get("core").containsKey(parameter)) + if (!ini.get("core").containsKey(parameter) && ! parameter.equals("CURRENT_OBJECT")) ConsoleWriter.detailsPrintln(DBGitLang.getInstance().getValue("errors", "config", "noParameter").withParams(parameter), messageLevel); else { getIni().get("core").put(parameter, value); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitObjectNotFound.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitObjectNotFound.java index 0d27866..04a5b09 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitObjectNotFound.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitObjectNotFound.java @@ -1,6 +1,6 @@ package ru.fusionsoft.dbgit.core; -public class ExceptionDBGitObjectNotFound extends ExceptionDBGit { +public class ExceptionDBGitObjectNotFound extends Error { private static final long serialVersionUID = 2163408974338332577L; diff --git a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java index a791bd6..8608625 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java @@ -97,10 +97,13 @@ private void addToMapSqlObject( } public boolean loadFromDB(IMetaObject obj) throws ExceptionDBGit { - boolean result = obj.loadFromDB(); - if (result) - dbObjs.put(obj); - return result; + try { + boolean result = obj.loadFromDB(); + if (result) dbObjs.put(obj); + return result; + } catch (ExceptionDBGitObjectNotFound ex) { + return false; + } } public IMetaObject getCacheDBMetaObject(String name) { diff --git a/src/main/java/ru/fusionsoft/dbgit/core/db/FieldType.java b/src/main/java/ru/fusionsoft/dbgit/core/db/FieldType.java index 30fe0c6..ba8c754 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/db/FieldType.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/db/FieldType.java @@ -10,7 +10,9 @@ public enum FieldType { NUMBER("number"), STRING("string"), STRING_NATIVE("string native"), - TEXT("text"); + ENUM("enum"), + TEXT("text"), + UNDEFINED(""); private String typeName; diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBCode.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBCode.java index 8510527..da9597e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBCode.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBCode.java @@ -10,6 +10,9 @@ * */ public class DBCode extends DBSQLObject { + public DBCode() { + } + public DBCode(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { super(name, options, schema, owner, dependencies, sql); } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBConstraint.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBConstraint.java index fe139c5..6ba5390 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBConstraint.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBConstraint.java @@ -12,6 +12,7 @@ public class DBConstraint extends DBSQLObject { @YamlOrder(4) private String constraintType; + public DBConstraint() { } public DBConstraint(String name, StringProperties options, String schema, String owner, Set dependencies, String sql, String constraintType) { super(name, options, schema, owner, dependencies, sql); this.constraintType = constraintType; diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBFunction.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBFunction.java index 790997a..c257530 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBFunction.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBFunction.java @@ -6,7 +6,7 @@ import java.util.Set; public class DBFunction extends DBCode { - + public DBFunction() { } public DBFunction(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { super(name, options, schema, owner, dependencies, sql); } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBIndex.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBIndex.java index c1879e0..96941ad 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBIndex.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBIndex.java @@ -7,6 +7,9 @@ public class DBIndex extends DBSQLObject { + public DBIndex() { + + } public DBIndex(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { super(name, options, schema, owner, dependencies, sql); } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBPackage.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBPackage.java index 4c49f61..d5b5ee3 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBPackage.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBPackage.java @@ -6,6 +6,7 @@ public class DBPackage extends DBCode { + public DBPackage() { } public DBPackage(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { super(name, options, schema, owner, dependencies, sql); } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBProcedure.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBProcedure.java index b4e8f75..d4b9767 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBProcedure.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBProcedure.java @@ -6,6 +6,7 @@ public class DBProcedure extends DBCode { + public DBProcedure() { } public DBProcedure(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { super(name, options, schema, owner, dependencies, sql); } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java index 9cb440a..48e4309 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSQLObject.java @@ -1,9 +1,9 @@ package ru.fusionsoft.dbgit.dbobjects; +import java.util.Collections; import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.utils.StringProperties; -import java.util.HashSet; import java.util.Set; /** @@ -15,6 +15,10 @@ public class DBSQLObject extends DBSchemaObject { protected String sql; + public DBSQLObject() { + super("", new StringProperties(), "", "", Collections.emptySet()); + } + public DBSQLObject(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { super(name, options, schema, owner, dependencies); this.sql = sql; @@ -39,5 +43,4 @@ public void setSql(String ddl) { this.sql = ddl; } - } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchemaObject.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchemaObject.java index c2763f9..16caad4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchemaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSchemaObject.java @@ -1,6 +1,7 @@ package ru.fusionsoft.dbgit.dbobjects; +import java.util.Collections; import ru.fusionsoft.dbgit.utils.StringProperties; import ru.fusionsoft.dbgit.yaml.YamlOrder; @@ -27,8 +28,8 @@ public abstract class DBSchemaObject extends DBOptionsObject { public DBSchemaObject(String name, StringProperties options, String schema, String owner, Set dependencies) { super(name, options); this.schema = schema; - this.owner = owner; - this.dependencies = dependencies; + this.owner = owner == null ? "" : owner; + this.dependencies = dependencies == null ? Collections.emptySet() : dependencies; } public String getSchema() { diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java index 614335d..1fee320 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBSequence.java @@ -1,5 +1,6 @@ package ru.fusionsoft.dbgit.dbobjects; +import java.util.Collections; import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.utils.StringProperties; @@ -8,6 +9,9 @@ public class DBSequence extends DBSchemaObject { protected Long value; + public DBSequence(){ + super("", new StringProperties(), "", "", Collections.emptySet()); + } public DBSequence(String name, StringProperties options, String schema, String owner, Set dependencies, Long value) { super(name, options, schema, owner, dependencies); this.value = value; diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java index 4fe4da7..78e7778 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTable.java @@ -13,9 +13,13 @@ public class DBTable extends DBSchemaObject { @YamlOrder(4) private String comment; + public DBTable() { + super("", new StringProperties(), "", "", Collections.emptySet()); + } + public DBTable(String name, StringProperties options, String schema, String owner, Set dependencies, String comment) { super(name, options, schema, owner, dependencies); - this.comment = comment; + this.comment = comment == null ? "" : comment; } @@ -35,16 +39,16 @@ public CalcHash addData(String str){ } public void setComment(String comment) { - this.comment = comment; + this.comment = comment == null ? "" : comment; } public String getComment() { return this.comment; } - public static class OnlyNamesDBTable extends DBTable{ + public static class OnlyNameDBTable extends DBTable{ - public OnlyNamesDBTable(String name, String schema) { + public OnlyNameDBTable(String name, String schema) { super(name, new StringProperties(), schema, "", Collections.emptySet(), ""); } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java index f00ba0c..7343a20 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTableField.java @@ -4,44 +4,61 @@ import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.yaml.YamlOrder; +import java.nio.channels.IllegalSelectorException; import java.util.Objects; public class DBTableField implements IDBObject, Comparable { @YamlOrder(0) - private String name; + private String name = ""; @YamlOrder(1) - private String description; + private String description = ""; @YamlOrder(2) - private Boolean isPrimaryKey; + private Boolean isPrimaryKey = false; @YamlOrder(3) - private Boolean isNullable; + private Boolean isNullable = false; @YamlOrder(4) - private String typeSQL; + private String typeSQL = ""; @YamlOrder(5) - private FieldType typeUniversal; + private FieldType typeUniversal = FieldType.UNDEFINED; @YamlOrder(6) - private Integer order; + private Integer order = -1; @YamlOrder(7) - private String defaultValue; + private String defaultValue = ""; @YamlOrder(8) - private int length; + private int length = 0; @YamlOrder(9) - private int scale; + private int scale = 0; @YamlOrder(10) - private int precision; + private int precision = 0; @YamlOrder(11) - private boolean fixed; + private boolean fixed = false; + + public DBTableField() { + //Just for things that want to introspect my guts and use setters + this.order = -1; + this.defaultValue = ""; + this.description = ""; + this.fixed = false; + this.isNullable = false; + this.isPrimaryKey = false; + this.length = 0; + this.name = ""; + this.precision = 0; + this.scale = 0; + this.typeSQL = ""; + this.typeUniversal = FieldType.UNDEFINED; + } public DBTableField(String name, String description, Boolean isPrimaryKey, Boolean isNullable, String typeSQL, FieldType typeUniversal, Integer order, String defaultValue, int length, int scale, int precision, boolean fixed) { this.name = name; - this.description = description; + this.description = description == null ? "" : description; this.isPrimaryKey = isPrimaryKey; this.isNullable = isNullable; this.typeSQL = typeSQL; this.typeUniversal = typeUniversal; this.order = order; - this.defaultValue = defaultValue; + this.defaultValue = defaultValue == null ? "" : defaultValue; this.length = length; this.scale = scale; this.precision = precision; @@ -92,50 +109,20 @@ public Boolean getIsPrimaryKey() { return isPrimaryKey; } - public void setIsPrimaryKey(Boolean isPrimaryKey) { - this.isPrimaryKey = isPrimaryKey; - } - public Boolean getIsNullable() { return isNullable; } - public void setIsNullable(Boolean isNullable) { this.isNullable = isNullable; } - - public void setTypeUniversal(FieldType typeUniversal) { - this.typeUniversal = typeUniversal; - } - public FieldType getTypeUniversal() { return typeUniversal; } - - public void setLength(int length) { - this.length = length; - } - - public int getLength() { - return length; - } - public void setScale(int scale) { - this.scale = scale; - } - - public int getScale() { - return scale; + public int getLength() { + return length; } - public void setPrecision(int precision) { - this.precision = precision; - } - public int getPrecision() { return precision; } - public void setFixed(boolean fixed) { - this.fixed = fixed; - } - public boolean getFixed() { return fixed; } @@ -144,42 +131,72 @@ public String getName() { return name; } - public void setName(String name) { - this.name = name; - } - public String getTypeSQL() { return typeSQL; } - public void setTypeSQL(String typeSQL) { - this.typeSQL = typeSQL; - } - - public void setOrder(Integer order) { - this.order = order; - } - public Integer getOrder() { return order; } - + public String getDefaultValue() { return this.defaultValue; } - public void setDefaultValue(String defaultValue) { - this.defaultValue = defaultValue; + public int getScale() { + return scale; } public String getDescription() { return this.description; } + public void setIsPrimaryKey(Boolean isPrimaryKey) { + this.isPrimaryKey = isPrimaryKey; + } + + public void setTypeUniversal(FieldType typeUniversal) { + this.typeUniversal = typeUniversal == null ? FieldType.UNDEFINED : typeUniversal; + } + + public void setIsNullable(Boolean isNullable) { this.isNullable = isNullable; } + + public void setLength(int length) { + this.length = length; + } + + public void setScale(int scale) { + this.scale = scale; + } + + public void setPrecision(int precision) { + this.precision = precision; + } + + public void setFixed(boolean fixed) { + this.fixed = fixed; + } + + public void setName(String name) { + this.name = name; + } + + public void setOrder(Integer order) { + this.order = order; + } + + public void setTypeSQL(String typeSQL) { + this.typeSQL = typeSQL; + } + + public void setDefaultValue(String defaultValue) { + this.defaultValue = defaultValue == null ? "" : defaultValue; + } + public void setDescription(String description) { - this.description = description; + this.description = description == null ? "" : description; } - + diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTrigger.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTrigger.java index ccb6a80..d38c4f1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTrigger.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBTrigger.java @@ -6,6 +6,7 @@ public class DBTrigger extends DBCode { + public DBTrigger() { } public DBTrigger(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { super(name, options, schema, owner, dependencies, sql); } diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBView.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBView.java index 3587dea..a543ec4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBView.java +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBView.java @@ -5,6 +5,7 @@ import java.util.Set; public class DBView extends DBSQLObject { + public DBView() { } public DBView(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { super(name, options, schema, owner, dependencies, sql); } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java index f408ab0..30d10cb 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaBase.java @@ -16,6 +16,7 @@ import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; import ru.fusionsoft.dbgit.core.db.DbType; +import ru.fusionsoft.dbgit.utils.StringProperties; import ru.fusionsoft.dbgit.yaml.DBGitYamlConstructor; import ru.fusionsoft.dbgit.yaml.DBGitYamlRepresenter; import ru.fusionsoft.dbgit.yaml.YamlOrder; @@ -95,8 +96,8 @@ public boolean yamlSerialize(OutputStream stream) throws IOException { public IMetaObject yamlDeSerialize(InputStream stream) { Yaml yaml = createYaml(); - - IMetaObject meta = yaml.loadAs(stream, this.getClass()); + //Map some = yaml.loadAs(stream, Map.class); + IMetaObject meta = yaml.loadAs(stream, this.getClass()); return meta; } @@ -111,6 +112,7 @@ public Yaml createYaml() { DumperOptions options = new DumperOptions(); options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK); options.setPrettyFlow(true); + Yaml yaml = new Yaml(new DBGitYamlConstructor(), new DBGitYamlRepresenter(), options); return yaml; } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaSql.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaSql.java index 252b331..7319170 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaSql.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaSql.java @@ -13,8 +13,7 @@ * */ public abstract class MetaSql extends MetaBase { - - + protected DBSQLObject sqlObject; public MetaSql() { setDbType(); diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java index 798696c..927a338 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTable.java @@ -11,6 +11,7 @@ import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.core.DBGitIndex; import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitObjectNotFound; import ru.fusionsoft.dbgit.dbobjects.*; import ru.fusionsoft.dbgit.utils.CalcHash; import ru.fusionsoft.dbgit.yaml.YamlOrder; @@ -72,12 +73,15 @@ public IMetaObject deSerialize(InputStream stream) { public boolean loadFromDB() throws ExceptionDBGit { IDBAdapter adapter = AdapterFactory.createAdapter(); NameMeta nm = MetaObjectFactory.parseMetaName(getName()); - - DBTable tbl = adapter.getTable(nm.getSchema(), nm.getName()); - if (tbl != null) - return loadFromDB(tbl); - else + try { + DBTable tbl = adapter.getTable(nm.getSchema(), nm.getName()); + if (tbl != null) + return loadFromDB(tbl); + else + return false; + } catch (ExceptionDBGitObjectNotFound exnf) { return false; + } } public boolean loadFromDB(DBTable tbl) throws ExceptionDBGit { diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index 40a2843..aa44bca 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -95,7 +95,7 @@ public void setTable(DBTable table) throws ExceptionDBGit { public void setName(String name) throws ExceptionDBGit { if (table == null) { NameMeta nm = MetaObjectFactory.parseMetaName(name); - table = new DBTable.OnlyNamesDBTable(nm.getName(), nm.getSchema()); + table = new DBTable.OnlyNameDBTable(nm.getName(), nm.getSchema()); } super.setName(name); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java index 7b48321..5a32860 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java @@ -365,8 +365,11 @@ private DBTableField DBTableFieldFromRs(ResultSet rs) throws SQLException { final int order = rs.getInt("order"); return new DBTableField( - columnName, columnDesc, isPrimaryKey, isNullable, - typeSQL, typeUniversal, order, columnDefault, + columnName, + columnDesc == null ? "" : columnDesc, + isPrimaryKey, isNullable, + typeSQL, typeUniversal, order, + columnDefault == null ? "" : columnDefault, length, precision, scale, isFixed ); diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java index 2d6ceda..d54f619 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBRestoreTableMssql.java @@ -5,6 +5,7 @@ import com.google.common.collect.MapDifference; import com.google.common.collect.MapDifference.ValueDifference; import com.google.common.collect.Maps; +import java.util.regex.Pattern; import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; import ru.fusionsoft.dbgit.adapters.IDBAdapter; import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; @@ -368,7 +369,6 @@ private void restoreTablePksMssql(MetaTable restoreTable, StatementLogging st) t if(pkConstraints.size() > 1) throw new SQLException(); for(DBConstraint pk : pkConstraints){ - String ddl = pk.getSql(); ddl = ddl.replaceFirst("ALTER TABLE\\s+\\[?\\w+\\]?.\\[?\\w+\\]?\\s+ADD\\s+CONSTRAINT\\s+\\[?\\w+\\]?\\s+", ""); ddl = MessageFormat.format( diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index aa80614..7200261 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -353,6 +353,14 @@ public Map getTableFields(String schema, String nameTable final boolean isPrimaryKey = rs.getString("constraint_name") != null; final boolean isNullable = !typeSQL.toLowerCase().contains("not null"); final FieldType typeUniversal = FieldType.fromString(rs.getString("tp")); +// System.out.println(( +// nameField +// + " > " +// + typeSQL +// + " (" +// + typeUniversal.toString() +// + ")" +// )); final FieldType actualTypeUniversal = typeUniversal.equals(FieldType.TEXT) ? FieldType.STRING_NATIVE : typeUniversal; final int length = rs.getInt("character_maximum_length"); final int precision = rs.getInt("numeric_precision"); @@ -616,9 +624,10 @@ public Map getTriggers(String schema) { String owner = "postgres"; String sql = rs.getString("ddl"); StringProperties options = new StringProperties(rs); - Set dependencies = rs.getArray("dependencies") == null - ? Collections.emptySet() - : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + Set dependencies = Collections.emptySet(); +// rs.getArray("dependencies") == null +// ? Collections.emptySet() +// : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); DBTrigger trigger = new DBTrigger(name, options, schema, owner, dependencies, sql); listTrigger.put(name, trigger); @@ -664,8 +673,7 @@ public DBTrigger getTrigger(String schema, String name) { } @Override public Map getPackages(String schema) { - throw new ExceptionDBGitRunTime(new ExceptionDBGitObjectNotFound("cannot get packages on postgres")); -// return Collections.emptyMap(); + return Collections.emptyMap(); } @Override @@ -779,9 +787,10 @@ public Map getFunctions(String schema) { String owner = rs.getString("rolname"); String sql = rs.getString("ddl"); StringProperties options = new StringProperties(rs); - Set dependencies = rs.getArray("dependencies") == null - ? Collections.emptySet() - : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); + Set dependencies = Collections.emptySet(); +// rs.getArray("dependencies") == null +// ? Collections.emptySet() +// : new HashSet<>(Arrays.asList((String[])rs.getArray("dependencies").getArray())); DBFunction dbFunction = new DBFunction(name, options, schema, owner, dependencies, sql); @@ -1728,4 +1737,4 @@ public String escapeNameIfNeeded(String name){ reservedWords.add("YEAR"); reservedWords.add("ZONE"); } -} \ No newline at end of file +} diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index ef62488..a03d9c5 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -35,7 +35,7 @@ general: removed: Remote removed unknown: Unknown command init: - created: Repository created + created: Repository created dump: checking: Checking files... dumping: Dumping... @@ -264,6 +264,7 @@ errors: rollback: Error while rollback! createSchema: Cannot create schema nullSchema: Object {0} has no schema set! + objectNotFoundInDb: Object is not found in target database! backup: badCommand: Bad command. Object to backup doesn't specified! backupError: Error on backup {0} @@ -406,4 +407,4 @@ help: config: | Example: dbgit config LIMIT_FETCH=true - config-g: sets global parameter \ No newline at end of file + config-g: sets global parameter diff --git a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java index ee781c1..9af0eac 100644 --- a/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/DBGitTest.java @@ -34,12 +34,12 @@ import java.util.*; -@Tag("pgTest") +@Tag("deprecated") @TestMethodOrder(MethodOrderer.OrderAnnotation.class) @TestInstance(TestInstance.Lifecycle.PER_CLASS) public class DBGitTest { - static Path RESOURCES_REPO_DIR = new File( "src/test/resources/repo").toPath(); + static Path RESOURCES_REPO_DIR = new File("src/test/resources/repo").toPath(); static Path RECOURCES_REPO_GIT_DIR = RESOURCES_REPO_DIR.resolve(".git"); static String REPO_URL = "https://github.com/rocket-3/dbgit-test.git"; @@ -48,20 +48,16 @@ public class DBGitTest { static String TEST_DB_URL = "jdbc:postgresql://localhost/"; static String TEST_DB_USER = "postgres"; - static String TEST_DB_PASS = "Kan:al*098"; + static String TEST_DB_PASS = ""; static String TEST_DB_CATALOG = "test#databasegit"; static boolean TO_CREATE_CATALOG = true; static int messageLevel = 0; - - //static String pgTestDbUrl = "jdbc:postgresql://135.181.94.98:31007/"; - //static String pgTestDbUser = "user"; - //static String pgTestDbPass = "42PoapGLGVnTdEYoUYFaFWXK"; - + private static void addCatalogToUrl() { TEST_DB_URL = MessageFormat.format( "{0}{1}{2}", TEST_DB_URL, - !TEST_DB_URL.endsWith("/") ? "/" : "", + TEST_DB_URL.endsWith("/") ? "" : "/", TEST_DB_CATALOG ); } @@ -489,8 +485,7 @@ private static void configureDBConnection() throws Exception { } private static void loadCommitNumbersFromRepo() throws GitAPIException, IOException { - DfsRepositoryDescription repoDesc = new DfsRepositoryDescription(); - InMemoryRepository repo = new InMemoryRepository(repoDesc); + InMemoryRepository repo = new InMemoryRepository(new DfsRepositoryDescription()); Git git = new Git(repo); git.fetch() .setRemote(REPO_URL) diff --git a/src/test/java/ru/fusionsoft/dbgit/MetaObjectTest.java b/src/test/java/ru/fusionsoft/dbgit/MetaObjectTest.java deleted file mode 100644 index b5fae39..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/MetaObjectTest.java +++ /dev/null @@ -1,135 +0,0 @@ -package ru.fusionsoft.dbgit; - -import java.io.File; -import java.io.FileInputStream; -import java.io.FileOutputStream; - -//import junit.framework.TestCase; -import ru.fusionsoft.dbgit.dbobjects.DBConstraint; -import ru.fusionsoft.dbgit.dbobjects.DBIndex; -import ru.fusionsoft.dbgit.dbobjects.DBSchema; -import ru.fusionsoft.dbgit.dbobjects.DBTable; -import ru.fusionsoft.dbgit.dbobjects.DBTableField; -import ru.fusionsoft.dbgit.meta.DBGitMetaType; -import ru.fusionsoft.dbgit.meta.MetaObjOptions; -import ru.fusionsoft.dbgit.meta.MetaObjectFactory; -import ru.fusionsoft.dbgit.meta.MetaSchema; -import ru.fusionsoft.dbgit.meta.MetaTable; -import ru.fusionsoft.dbgit.utils.StringProperties; - -public class MetaObjectTest /*extends TestCase*/ { - public final String targetPath = "target"; - - /* - public void testMetaTable() { - DBTable tbl = new DBTable(); - - tbl.setName("mytable"); - tbl.setSchema("myschema"); - tbl.getOptions().addChild("owner", "postgres"); - tbl.getOptions().addChild("table_space", "pg_default"); - StringProperties sub = (StringProperties)tbl.getOptions().addChild("sub"); - sub.addChild("sub1", "val1"); - sub.addChild("sub2", "val2"); - - MetaTable tblMeta = new MetaTable(tbl); - - DBTableField field = new DBTableField(); - field.setName("id"); - field.setTypeSQL("integer"); - field.setIsPrimaryKey(true); - tblMeta.getFields().put(field.getName(), field); - - field = new DBTableField(); - field.setName("field1"); - field.setTypeSQL("character varying(255)"); - field.setIsPrimaryKey(false); - tblMeta.getFields().put(field.getName(), field); - - field = new DBTableField(); - field.setName("field2"); - field.setTypeSQL("timestamp without time zone"); - tblMeta.getFields().put(field.getName(), field); - - field = new DBTableField(); - field.setName("field3"); - field.setTypeSQL("integer"); - tblMeta.getFields().put(field.getName(), field); - - DBIndex idx = new DBIndex(); - idx.setName("idx1"); - idx.setSchema("myschema"); - idx.setSql("CREATE INDEX idx1 ON crtd.notice USING btree (depart);"); - tblMeta.getIndexes().put(idx.getName(), idx); - - idx = new DBIndex(); - idx.setName("idx2"); - idx.setSchema("myschema"); - idx.setSql("CREATE INDEX idx2 ON crtd.notice USING btree (depart);"); - tblMeta.getIndexes().put(idx.getName(), idx); - - DBConstraint ct = new DBConstraint(); - ct.setName("fk1"); - ct.setSchema("myschema"); - ct.setSql("ALTER TABLE crtd.notice ADD CONSTRAINT fk1 FOREIGN KEY (arrive) REFERENCES crtd.ptstation (id) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION;"); - tblMeta.getConstraints().put(ct.getName(), ct); - - ct = new DBConstraint(); - ct.setName("fk2"); - ct.setSchema("myschema"); - ct.setSql("ALTER TABLE crtd.notice ADD CONSTRAINT fk2 FOREIGN KEY (arrive) REFERENCES crtd.ptstation (id) MATCH SIMPLE ON UPDATE NO ACTION ON DELETE NO ACTION;"); - tblMeta.getConstraints().put(ct.getName(), ct); - - try { - String filename = targetPath+"/test.yaml"; - FileOutputStream out = new FileOutputStream(filename); - tblMeta.serialize(out); - out.close(); - - - File file = new File(filename); - FileInputStream fis = new FileInputStream(file); - MetaTable meta2 = (MetaTable)tblMeta.deSerialize(fis); - fis.close(); - - assertEquals("Assert meta name!", "myschema/mytable.tbl", meta2.getName()); - assertEquals("Assert meta name!", "mytable", meta2.getTable().getName()); - assertEquals("Assert meta name!", "val1", meta2.getTable().getOptions().xPath("sub/sub1").getData()); - - assertEquals("Assert meta hash!", tblMeta.getHash(), meta2.getHash()); - //assertEquals("Assert meta hash!", tblMeta.getHash(), "hash"); - - - } catch (Exception e) { - e.printStackTrace(); - assertTrue(e.getMessage(), false ); - } - } - - */ - -// public void testMetaShema() throws Exception { -// DBSchema sh = new DBSchema("myshema"); -// StringProperties pr = sh.getOptions(); -// pr.setData("info value"); -// pr.addChild("param1", "val1"); -// pr.addChild("param2", "val2"); -// pr.addChild("param3", "val3"); -// -// StringProperties sub = pr.addChild("subparams"); -// sub.addChild("subparam1", "asd1"); -// sub.addChild("subparam2", "asd2"); -// -// MetaObjOptions meta = (MetaObjOptions)MetaObjectFactory.createMetaObject(DBGitMetaType.DBGitSchema); -// meta.setObjectOption(sh); -// -// //assertEquals("Assert hash!", meta.getHash(), "5c376e1836f4cbc763808fe077a84f2eaf9cdb9dc7e22107fc44a9567f4cf264"); -// -// /* -// System.out.println(meta.getHash()); -// -// System.out.println(pr.toString()); -// */ -// //TODO to yaml and assert -// } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/UtilTest.java b/src/test/java/ru/fusionsoft/dbgit/UtilTest.java deleted file mode 100644 index 405598a..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/UtilTest.java +++ /dev/null @@ -1,61 +0,0 @@ -package ru.fusionsoft.dbgit; - -import org.junit.jupiter.api.*; -import static org.junit.jupiter.api.Assertions.*; - - - - -public class UtilTest { - - @Test - public void testMask() { - /* - MaskFilter mask = new MaskFilter("asd*.txt"); - assertTrue(mask.match("asd12df.txt")); - assertFalse(mask.match("as612df.txt")); - - mask = new MaskFilter("path/asd*.txt"); - assertTrue(mask.match("path/asd12df.txt")); - assertFalse(mask.match("as612df.txt")); - - mask = new MaskFilter("path/*"); - assertTrue(mask.match("path/asd12df.txt")); - assertFalse(mask.match("pat/as612df.txt")); - - mask = new MaskFilter("path/w*"); - assertTrue(mask.match("path\\wsd12df.txt")); - assertFalse(mask.match("pat\\ws612df.txt")); - */ - } - @Test - public void testMapField() { - /* - IMapFields map = new TreeMapFields(); - - DBTableField f1 = new DBTableField(); - f1.setName("f1"); - DBTableField f2 = new DBTableField(); - f2.setName("f2"); - DBTableField f3 = new DBTableField(); - f3.setName("f3"); - DBTableField f4 = new DBTableField(); - f4.setName("f4"); - - - for (int i = 0; i < 10000; i++) { - DBTableField f = new DBTableField(); - f.setName("item_"+Math.random()*10000000); - map.put(f); - } - - - map.put(f2); - map.put(f1); - map.put(f3); - map.put(f4); - */ - - - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/ClassCompositionTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/ClassCompositionTest.java new file mode 100644 index 0000000..bde1fc3 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/ClassCompositionTest.java @@ -0,0 +1,200 @@ +package ru.fusionsoft.dbgit.integration; + +import java.nio.file.Path; +import org.apache.commons.io.FileUtils; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import ru.fusionsoft.dbgit.integration.primitives.TestResult; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCloningGitRepo; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFiles; +import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPrintsToConsole; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; +import ru.fusionsoft.dbgit.integration.primitives.DescribedTestResult; +import ru.fusionsoft.dbgit.integration.primitives.GrouppedTR; +import ru.fusionsoft.dbgit.integration.primitives.Patch; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequental; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTest; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTestResult; + +public class ClassCompositionTest { + + @Test + public final void subjectSideEffectAppearsOnceWhenAccessingTwice() throws Exception { + Assertions.assertEquals( + 2, + new DescribedTestResult( + "Test result subject side effect appears once", + new SimpleTestResult( + new PathPrintsToConsole( + "Line printed as side effect...", + new ProjectTestResourcesCleanDirectoryPath( + "Test result subject side effect appears once" + ) + ), + subj -> { + subj.isAbsolute(); + subj.toString(); + subj.toFile(); + return true; + } + ) + ) + .text() + .split("\n") + .length + ); + } + + @Test + public final void failsToFalseOnException() { + final ProjectTestResourcesCleanDirectoryPath workingDirectory = + new ProjectTestResourcesCleanDirectoryPath( + "Fails to false on exception"); + + Assertions.assertDoesNotThrow( + () -> { + final TestResult testResult = + new DescribedTestResult( + "Fails to false on exception", + new SimpleTestResult( + new PathPatched( + new PathNotProjectRoot(workingDirectory), + new Patch() { + @Override + public void apply(Path root) throws Exception { + System.out.println("access " + root.toString()); + throw new Error( + "dummy error" + ); + } + } + ), + path -> { + path.toString(); + path.toString(); + path.toString(); + path.toString(); + return ! path + .resolve("pom.xml") + .toFile() + .exists(); + } + ) + ); + + System.out.println(testResult.text()); + Assertions.assertFalse(testResult.value()); + } + ); + } + + @Test + public final void groupedTestResultWorks() { + final DescribedTestResult result = new DescribedTestResult( + "Grouped test result works", + new GrouppedTR( + new ProjectTestResourcesCleanDirectoryPath( + "Grouped test result works" + ), + new SimpleTest<>( + "Retruns true", + (path) -> { + path.toString(); + return true; + } + ), + new SimpleTest<>( + "Throws exception", + (path) -> { + path.toString(); + throw new Exception("dummy expection"); + } + ), + new SimpleTest<>( + "Throws error", + (path) -> { + path.toString(); + throw new Error("dummy error the second"); + } + ) + ) + ); + System.out.println(result.text()); + Assertions.assertFalse(result.value()); + } + + @Test + public final void patchedWorks() { + final ProjectTestResourcesCleanDirectoryPath workingDirectory = + new ProjectTestResourcesCleanDirectoryPath( + "Patched works" + ); + + final String fileName = "testFile.txt"; + final String content = "content"; + + final DescribedTestResult result = new DescribedTestResult( + "Patched works", + new GrouppedTR<>( + new PathPatched( + new PathNotProjectRoot(workingDirectory), + new PathPatchCreatingFile(fileName, content) + ), + + new SimpleTest<>( + "Файл существует", + path -> { + return path.resolve(fileName).toFile().exists(); + } + ), + new SimpleTest<>( + "Содержимое файла как ожидалось", + path -> { + return FileUtils.readFileToString( + path.resolve(fileName).toFile() + ) + .contains(content); + } + ) + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void patchSequentalWorks() { + final DescribedTestResult result = new DescribedTestResult( + "Sequental patch works", + new SimpleTestResult<>( + new PathPatched( + new PathNotProjectRoot( + new ProjectTestResourcesCleanDirectoryPath( + "Sequental patch works" + ) + ), + new PatchSequental<>( + new PathPatchDeletingFiles(".git", ".dbgit"), + new PathPatchCloningGitRepo( + "https://github.com/rocket-3/dbgit-test.git", + "master" + ) + ) + ), + new SimpleTest<>( + "Git folder exists", + x -> x.resolve(".git").toFile().exists() + ) + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitTest.java new file mode 100644 index 0000000..dc425d5 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitTest.java @@ -0,0 +1,434 @@ +package ru.fusionsoft.dbgit.integration; + +import java.nio.file.Path; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import ru.fusionsoft.dbgit.integration.primitives.DescribedTestResult; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTest; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTestResult; +import ru.fusionsoft.dbgit.integration.primitives.TestResult; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsCheckoutNodb; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.AutoPgLinkArgs; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.GitTestRepoAddRemoteArgs; +import ru.fusionsoft.dbgit.integration.primitives.chars.SavedConsoleText; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRestore; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRun; +import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; +import ru.fusionsoft.dbgit.integration.primitives.path.PathWithBuildingDbGitExecutableFromGit; +import ru.fusionsoft.dbgit.integration.primitives.path.PathWithDbGitRepoInitialized; +import ru.fusionsoft.dbgit.integration.primitives.path.PathWithFiles; +import ru.fusionsoft.dbgit.integration.primitives.path.PathWithoutFiles; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; + +@Tag("integration") +public class DbGitTest { + + @Test + public final void clonesRepoAndReturnsCurrentCommitNumber() throws Exception { + final Path workingDirectory = + new ProjectTestResourcesCleanDirectoryPath( + "Clones repo and prints expected commit hash") + .toAbsolutePath(); + + final String commitHash = "b1fecd7"; + + final TestResult testResult = new DescribedTestResult<>( + "Dbgit clone works as expected", + new SavedConsoleText( + () -> { + new PathAfterDbGitRun( + new ArgsExplicit( + "checkout", + "-ls", "-v" + ), + System.out, + new PathAfterDbGitRun( + new ArgsExplicit( + "checkout", + "master", + commitHash, + "-nodb" + ), + new PathAfterDbGitRun( + new GitTestRepoAddRemoteArgs("origin"), + + new PathAfterDbGitRun( + new ArgsExplicit("init"), + + new PathAfterDbGitRun( + new ArgsExplicit( + "clone", + "https://github.com/rocket-3/dbgit-test.git", + "--directory", + "\"" + workingDirectory + .toString() + "\"" + ), + + new PathWithoutFiles( + "*", + new PathNotProjectRoot( + workingDirectory + ) + ) + ) + ) + ) + ) + ).toString(); + } + ), + new SimpleTest( + "Printed expected commit hash", + (text) -> { + return text + .lines() + .stream() + .anyMatch( + (line) -> line.contains(commitHash) + ); + } + ) + ); + + System.out.println(testResult.text()); + Assertions.assertTrue(testResult.value()); + } + + @Test + public final void fetchesDatabaseObjects() { + final Path workingDirectory = + new ProjectTestResourcesCleanDirectoryPath("fetchesDatabaseObjects") + .toAbsolutePath(); + + final DescribedTestResult result = new DescribedTestResult<>( + "Dbgit add command test", + new SimpleTestResult<>( + new PathAfterDbGitRun( + new ArgsExplicit("add", "\"*\""), + new PathAfterDbGitRun( + new AutoPgLinkArgs("pagilla"), + new PathAfterDbGitRun( + new ArgsExplicit("init"), + new PathWithoutFiles( + "*", + new PathNotProjectRoot( + workingDirectory + ) + ) + ) + ) + ), + new SimpleTest<>( + (path) -> { + return path.resolve(".git").toFile().exists(); + } + ) + ) + ); + + System.out.println("\n" + result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void fetchesAndCommitsWholeNewStructure() { + final Path workingDirectory = + new ProjectTestResourcesCleanDirectoryPath( + "fetchesAndCommitsWholeNewStructure") + .toAbsolutePath(); + + final DescribedTestResult result = new DescribedTestResult( + "Dbgit add command test", + new SimpleTestResult<>( + new PathAfterDbGitRun( + new ArgsExplicit("push"), + new PathAfterDbGitRun( + new ArgsExplicit( + "commit", + "-m", + "Pagilla database" + ), + new PathAfterDbGitRun( + new ArgsExplicit("add", "\"*\""), + // dbgit rm -idx + // can't work without MetaFile parsing, which + // is unstable during current development + //new PathAfterAppRunInProcess(new ExplicitArgs("rm","\"*\"", "-idx"), + new PathWithFiles( + new PathPatchCreatingFile( + ".dbgit/.dbindex", + "version=0.3.1" + ), + new PathWithoutFiles( + new String[]{".dbgit/public"}, + new PathAfterDbGitRun( + new ArgsExplicit( + "checkout", + "ng", + "-nodb" + ), + new PathAfterDbGitRun( + new AutoPgLinkArgs("dvdrental"), + new PathAfterDbGitRun( + new ArgsExplicit( + "checkout", + "master", + "-nodb" + ), + new PathAfterDbGitRun( + new GitTestRepoAddRemoteArgs("origin"), + new PathAfterDbGitRun( + new ArgsExplicit("init"), + new PathAfterDbGitRun( + new ArgsExplicit( + "clone", + "https://github.com/rocket-3/dbgit-test.git", + "--directory", + "\"" + + workingDirectory + .toString() + + "\"" + ), + new PathWithoutFiles( + "*", + new PathNotProjectRoot( + workingDirectory + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + + ), + new SimpleTest<>( + (path) -> { + return path.resolve(".git").toFile().exists(); + } + ) + ) + ); + + System.out.println("\n" + result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void commitsLilChangedDbSchema() { + final Path workingDirectory = + new ProjectTestResourcesCleanDirectoryPath( + "commitsLilChangedDbSchema") + .toAbsolutePath(); + + final DescribedTestResult result = new DescribedTestResult<>( + "Dbgit add command test", + new SimpleTestResult<>( + new PathAfterDbGitRun( + new ArgsExplicit( + "push" + ), + + new PathAfterDbGitRun( + new ArgsExplicit( + "commit", + "-m", + "Sakilla database" + ), + + new PathAfterDbGitRun( + new ArgsExplicit( + "add", + "\"*\"" + ), + + new PathAfterDbGitRun( + new AutoPgLinkArgs("dvdrental"), + + new PathAfterDbGitRun( + new ArgsExplicit( + "checkout", + "ng", + "-nodb" + ), + + new PathAfterDbGitRun( + new GitTestRepoAddRemoteArgs("origin"), + + new PathAfterDbGitRun( + new ArgsExplicit("init"), + + new PathAfterDbGitRun( + new ArgsExplicit( + "clone", + "https://github.com/rocket-3/dbgit-test.git", + "--directory", + "\"" + workingDirectory + .toString() + "\"" + ), + + new PathWithoutFiles( + "*", + new PathNotProjectRoot( + workingDirectory + ) + ) + ) + ) + ) + ) + + ) + ) + ) + + ), + new SimpleTest<>( + (path) -> { + return path.resolve(".git").toFile().exists(); + } + ) + ) + ); + + System.out.println("\n" + result.text()); + Assertions.assertTrue(result.value()); + + } + + @Test + public final void usesAnotherDbGitVersionToRestore() { + + final Path olderDbGitExecutablePath = new PathWithBuildingDbGitExecutableFromGit( + "51e8fa0", + new ProjectTestResourcesCleanDirectoryPath("dbgit version 51e8fa0") + ); + final ArgsLink testDbLinkArgsMoniker = new AutoPgLinkArgs("test#databasegit"); + final TestResult result = new DescribedTestResult<>( + "Uses older dbgit version to prepare database", + new SimpleTestResult<>( + new PathAfterDbGitRestore( + new ArgsCheckoutNodb("master", "8867384"), + testDbLinkArgsMoniker, + olderDbGitExecutablePath, + new PathAfterDbGitRestore( + new ArgsCheckoutNodb("master", "b1fecd7"), + testDbLinkArgsMoniker, + olderDbGitExecutablePath, + new PathAfterDbGitRestore( + new ArgsCheckoutNodb("master", "831054e"), + testDbLinkArgsMoniker, + olderDbGitExecutablePath, + new PathAfterDbGitRestore( + new ArgsCheckoutNodb("master", "d2b4080"), + testDbLinkArgsMoniker, + olderDbGitExecutablePath, + + new PathAfterDbGitRestore( + new ArgsCheckoutNodb("master", "4f3953d"), + testDbLinkArgsMoniker, + olderDbGitExecutablePath, + + new PathWithDbGitRepoInitialized( + "https://github.com/rocket-3/dbgit-test.git", + + new ProjectTestResourcesCleanDirectoryPath( + "usesAnotherDbGitVersionToRestore" + ) + ) + ) + ) + ) + ) + ), + new SimpleTest<>( + "Exception not thrown", + (path) -> { + path.toString(); + return true; + } + ) + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void createsAndUpdatesDatabase() { + final String description = "Fills and updates database from different repos"; + final Path workingDirectory = new ProjectTestResourcesCleanDirectoryPath( + description + ) + .toAbsolutePath(); + + + final TestResult result = new DescribedTestResult( + description, + new SimpleTestResult<>( + new PathAfterDbGitRun( + new ArgsExplicit("restore", "-r", "-v"), + + new PathAfterDbGitRun( + new AutoPgLinkArgs("test#databasegit"), + + new PathAfterDbGitRun( + new ArgsExplicit("add", "\"*\""), + + new PathAfterDbGitRun( + new AutoPgLinkArgs("pagilla"), + new PathAfterDbGitRun( + new ArgsExplicit("restore", "-r", "-v"), + System.out, + new PathAfterDbGitRun( + new AutoPgLinkArgs("test#databasegit"), + + new PathAfterDbGitRun( + new ArgsExplicit("add", "\"*\""), + + new PathAfterDbGitRun( + new AutoPgLinkArgs("dvdrental"), + + new PathAfterDbGitRun( + new ArgsExplicit("init"), + + new PathWithoutFiles( + "*", + new PathNotProjectRoot( + workingDirectory + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ), + new SimpleTest<>( + "Exception not thrown", + (path) -> { + path.toString(); + return true; + } + ) + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/StickyFunctionTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/StickyFunctionTest.java new file mode 100644 index 0000000..caf5371 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/StickyFunctionTest.java @@ -0,0 +1,31 @@ +package ru.fusionsoft.dbgit.integration; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import ru.fusionsoft.dbgit.integration.primitives.Function; +import ru.fusionsoft.dbgit.integration.primitives.StickyFunction; + +import java.util.concurrent.atomic.AtomicInteger; + +public class StickyFunctionTest { + + @Test + public void returnsValue() throws Exception { + Assertions.assertEquals( + 4, + new StickyFunction( (x) -> x+2 ).value(2) + ); + } + + @Test + public void returnsSameValue() throws Exception { + final AtomicInteger accessCount = new AtomicInteger(0); + final Function sticky = new StickyFunction<>( + (x) -> accessCount.incrementAndGet() + ); + Assertions.assertEquals( + sticky.value(0), + sticky.value(0) + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterDbGitMainRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterDbGitMainRun.java new file mode 100644 index 0000000..97d3d6a --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterDbGitMainRun.java @@ -0,0 +1,35 @@ +package ru.fusionsoft.dbgit.integration.deprecated; + +import java.nio.file.Path; +import java.util.Arrays; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.path.PathEnvelope; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; + +public class PathAfterDbGitMainRun extends PathEnvelope { + public PathAfterDbGitMainRun(Args args, Path origin) { + super(() -> { + final boolean originIsNotAppWorkingDirectory = ( + ! new CurrentWorkingDirectory() + .toAbsolutePath() + .toString() + .equals(origin.toAbsolutePath().toString()) + ); + if ( originIsNotAppWorkingDirectory ) { + throw new RuntimeException( + "Given path:" + + "\n->" + origin.toAbsolutePath().toString() + + "\nis not an App's working directory:" + + "\n->" + new CurrentWorkingDirectory().toAbsolutePath().toString() + + "\nSo App cant apply to the given Path" + ); + } + origin.toString(); + System.out.println("\n> dbgit " + String.join( + " ", + Arrays.asList(args.values()) + )); + return new WithDbGitMainRunScalar<>(args, origin).value(); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterExecutableRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterExecutableRun.java new file mode 100644 index 0000000..8d4c1fd --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterExecutableRun.java @@ -0,0 +1,88 @@ +package ru.fusionsoft.dbgit.integration.deprecated; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithPrepend; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterCommandRun; +import ru.fusionsoft.dbgit.integration.primitives.path.PathEnvelope; + +public class PathAfterExecutableRun extends PathEnvelope { + public PathAfterExecutableRun( + Args commandInterface, + CharSequence executableName, + Args command, + PrintStream printStream, + Path origin + ) { + super( + () -> + new PathAfterCommandRun( + new ArgsWithPrepend( + new ArgsWithPrepend( + command, + executableName + ), + commandInterface + ), + printStream, + origin + ) + ); + } + + public PathAfterExecutableRun( + Args commandInterface, + CharSequence executableName, + Args executableArgs, + Path workingDirectory + ) { + this( + commandInterface, + executableName, + executableArgs, + new NullPrintStream(), + workingDirectory + ); + } + + public PathAfterExecutableRun( + CharSequence executableName, + Args args, + PrintStream printStream, + Path workingDirectory + ) { + this( + new ArgsExplicit(System.getenv("ComSpec"), "/C"), + executableName, + args, + printStream, + workingDirectory + ); + } + + public PathAfterExecutableRun( + CharSequence executableName, + Args args, + Path workingDirectory + ) { + this( + executableName, + args, + new NullPrintStream(), + workingDirectory + ); + } + + public PathAfterExecutableRun(Path executablePath, Args args, Path workingDirectory) { + this( + new CharsOf<>(Path::toString, executablePath), + args, + workingDirectory + ); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/SystemUserDirPath.java b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/SystemUserDirPath.java new file mode 100644 index 0000000..75dc48b --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/SystemUserDirPath.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.deprecated; + +import java.nio.file.Paths; +import ru.fusionsoft.dbgit.integration.primitives.path.PathEnvelope; + +public class SystemUserDirPath extends PathEnvelope { + public SystemUserDirPath(){ + super(()->Paths.get(System.getProperty("user.dir"))); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/WithDbGitMainRunScalar.java b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/WithDbGitMainRunScalar.java new file mode 100644 index 0000000..b65fc19 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/WithDbGitMainRunScalar.java @@ -0,0 +1,26 @@ +package ru.fusionsoft.dbgit.integration.deprecated; + +import java.util.Arrays; +import ru.fusionsoft.dbgit.App; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; + +public class WithDbGitMainRunScalar implements Scalar { + private final Args args; + private final Y origin; + + public WithDbGitMainRunScalar(Args args, Y origin) { + this.args = args; + this.origin = origin; + } + + @Override + public final Y value() throws Exception { + App.main( + Arrays.stream(this.args.values()) + .map(String::valueOf) + .toArray(String[]::new) + ); + return origin; + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Args.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Args.java new file mode 100644 index 0000000..a6b95e6 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Args.java @@ -0,0 +1,5 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public interface Args { + CharSequence[] values(); +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Credentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Credentials.java new file mode 100644 index 0000000..08e0b4d --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Credentials.java @@ -0,0 +1,6 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public interface Credentials { + String username() ; + String password() ; +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/DescribedTestResult.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/DescribedTestResult.java new file mode 100644 index 0000000..26ac91e --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/DescribedTestResult.java @@ -0,0 +1,45 @@ +package ru.fusionsoft.dbgit.integration.primitives; +import java.text.MessageFormat; +import java.util.regex.Pattern; +import ru.fusionsoft.dbgit.integration.primitives.chars.TestSuccessMarkChars; + +public class DescribedTestResult implements TestResult { + private final String description; + private final TestResult testResult; + + public DescribedTestResult(String description, Subj subject, Test test) { + this.description = description; + this.testResult = new SimpleTestResult<>(subject, test); + } + + public DescribedTestResult(String description, TestResult simpleTestResult) { + this.description = description; + this.testResult = simpleTestResult; + } + + @Override + public final boolean value() { + return this.testResult.value(); + } + + @Override + public final String text() { + final String valueChars = String.valueOf( + new TestSuccessMarkChars(this.testResult.value()) + ); + + return this.testResult + .text() + .replaceFirst( + Pattern.quote(valueChars), + MessageFormat.format( + "{0} {1} -", + valueChars, + this.description + ) + + ); + + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Function.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Function.java new file mode 100644 index 0000000..232e585 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Function.java @@ -0,0 +1,6 @@ +package ru.fusionsoft.dbgit.integration.primitives; + + +public interface Function{ + Y value(X source) throws Exception; +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GrouppedTR.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GrouppedTR.java new file mode 100644 index 0000000..fe30692 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GrouppedTR.java @@ -0,0 +1,34 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +import java.util.Arrays; +import java.util.Collection; +import java.util.stream.Collectors; +import ru.fusionsoft.dbgit.integration.primitives.chars.TestSuccessMarkChars; + +public class GrouppedTR implements TestResult { + private final Collection testResults; + + @SafeVarargs + public GrouppedTR(Subj subject, Test... tests ) { + this.testResults = Arrays.stream(tests) + .map(test -> new SimpleTestResult<>(subject, test)) + .collect(Collectors.toList()); + } + + @Override + public final boolean value() { + return testResults + .stream() + .allMatch(TestResult::value); + } + + @Override + public final String text() { + return new TestSuccessMarkChars(this.value()) + + "\n\t" + + testResults + .stream() + .map(TestResult::text) + .collect(Collectors.joining("\t")); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/NullPrintStream.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/NullPrintStream.java new file mode 100644 index 0000000..4da0621 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/NullPrintStream.java @@ -0,0 +1,14 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +import java.io.OutputStream; +import java.io.PrintStream; + +public class NullPrintStream extends PrintStream { + + public NullPrintStream() { + super(new OutputStream() { + @Override + public void write (int b) { } + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Patch.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Patch.java new file mode 100644 index 0000000..c5685e4 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Patch.java @@ -0,0 +1,8 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +/* + A consumer, but can throw checked + */ +public interface Patch { + void apply(T root) throws Exception; +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequental.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequental.java new file mode 100644 index 0000000..3226aa9 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequental.java @@ -0,0 +1,24 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +import java.util.Arrays; +import java.util.Collection; + +public class PatchSequental implements Patch { + private final Collection> patches; + + public PatchSequental(final Collection> patches) { + this.patches = patches; + } + + @SafeVarargs + public PatchSequental(final Patch... patches) { + this(Arrays.asList(patches)); + } + + @Override + public final void apply(final T root) throws Exception { + for (final Patch patch : patches) { + patch.apply(root); + } + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchedScalar.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchedScalar.java new file mode 100644 index 0000000..9e5ab58 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchedScalar.java @@ -0,0 +1,17 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public class PatchedScalar implements Scalar { + private final T origin; + private final Patch patch; + + public PatchedScalar(T origin, Patch patch) { + this.origin = origin; + this.patch = patch; + } + + @Override + public final T value() throws Exception { + this.patch.apply(origin); + return origin; + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/RunnableWithException.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/RunnableWithException.java new file mode 100644 index 0000000..c5b7358 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/RunnableWithException.java @@ -0,0 +1,5 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public interface RunnableWithException { + void run() throws Exception; +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalar.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalar.java new file mode 100644 index 0000000..f4c756b --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalar.java @@ -0,0 +1,5 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public interface SafeScalar { + T value(); +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalarOf.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalarOf.java new file mode 100644 index 0000000..f931413 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalarOf.java @@ -0,0 +1,25 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public class SafeScalarOf implements SafeScalar { + private final Scalar origin; + + public SafeScalarOf(Scalar origin) { + this.origin = origin; + } + + public SafeScalarOf(Function origin, X value){ + this( () -> origin.value(value) ) ; + } + + @Override + public final Y value() { + try { + return origin.value(); + } catch (Exception e) { + throw new Error( + "Exception occurs while constructing safe scalar value", + e + ); + } + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Scalar.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Scalar.java new file mode 100644 index 0000000..cc822de --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Scalar.java @@ -0,0 +1,8 @@ +package ru.fusionsoft.dbgit.integration.primitives; + + +public interface Scalar { + T value() throws Exception; + + Scalar DONT_CARE = () -> { throw new Exception("Not implemented"); }; +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTest.java new file mode 100644 index 0000000..93d0bf2 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTest.java @@ -0,0 +1,26 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public class SimpleTest implements Test { + private final Function predicate; + private final String description; + + public SimpleTest(String description, Function predicate) { + this.description = description; + this.predicate = predicate; + } + + public SimpleTest(Function predicate) { + this.description = "test just runs without errors"; + this.predicate = predicate; + } + + @Override + public final boolean value(Subj subj) throws Exception { + return this.predicate.value(subj); + } + + @Override + public final String description() { + return this.description; + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTestResult.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTestResult.java new file mode 100644 index 0000000..6bc0f75 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTestResult.java @@ -0,0 +1,29 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +import ru.fusionsoft.dbgit.integration.primitives.chars.TestSuccessMarkChars; +import ru.fusionsoft.dbgit.integration.primitives.chars.TestResultDetailedChars; + +public class SimpleTestResult implements TestResult { + + private final CharSequence text; + + public SimpleTestResult(Subj subject, Test test) { + this.text = new TestResultDetailedChars<>(subject, test); + } + + public SimpleTestResult(Subj subject, Function testFunction) { + this.text = new TestResultDetailedChars<>(subject, new SimpleTest<>(testFunction)); + } + + @Override + public final String text() { + return String.valueOf(this.text); + } + + @Override + public final boolean value() { + return this.text().contains( + String.valueOf(new TestSuccessMarkChars(true)) + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyFunction.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyFunction.java new file mode 100644 index 0000000..0fe0651 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyFunction.java @@ -0,0 +1,30 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +import java.util.HashMap; +import java.util.Map; + +public class StickyFunction implements Function { + private final Function origin; + private final Map cachedValues; + + private StickyFunction(Function origin, Map cachedValues) { + this.origin = origin; + this.cachedValues = cachedValues; + } + + public StickyFunction(Function origin){ + this(origin, new HashMap<>()); + } + + public StickyFunction(Scalar origin){ + this((x) -> origin.value()); + } + + @Override + public Y value(X arg) throws Exception { + if (!cachedValues.containsKey(arg)) { + cachedValues.put(arg, origin.value(arg)); + } + return cachedValues.get(arg); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyScalar.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyScalar.java new file mode 100644 index 0000000..a79c5fe --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyScalar.java @@ -0,0 +1,25 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public class StickyScalar implements Scalar { + private final Function origin; + + public StickyScalar(Scalar origin) { + this.origin = new StickyFunction<>(origin); + } + + public StickyScalar(Function origin, X value) { + this( + new Scalar() { + @Override + public Y value() throws Exception { + return origin.value(value); + } + } + ); + } + + @Override + public final Y value() throws Exception { + return this.origin.value(true); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Test.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Test.java new file mode 100644 index 0000000..8686e04 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/Test.java @@ -0,0 +1,6 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public interface Test { + String description(); + boolean value(Subj subj) throws Exception; +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/TestResult.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/TestResult.java new file mode 100644 index 0000000..1409c54 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/TestResult.java @@ -0,0 +1,6 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +public interface TestResult { + String text(); + boolean value(); +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsCheckoutNodb.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsCheckoutNodb.java new file mode 100644 index 0000000..0d56e91 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsCheckoutNodb.java @@ -0,0 +1,12 @@ +package ru.fusionsoft.dbgit.integration.primitives.args; +public class ArgsCheckoutNodb extends ArgsExplicit { + + public ArgsCheckoutNodb(String branchName, String commitHash) { + super( + "checkout", + branchName, + commitHash, + "-nodb" + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsDbGitAddRemote.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsDbGitAddRemote.java new file mode 100644 index 0000000..9bce2a4 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsDbGitAddRemote.java @@ -0,0 +1,15 @@ +package ru.fusionsoft.dbgit.integration.primitives.args; + +public class ArgsDbGitAddRemote extends ArgsExplicit { + public ArgsDbGitAddRemote(String url, String name, String user, String pass) { + super( + "remote", "add", name, + "https://" + + user + + ":" + + pass + + "@" + + url + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsExplicit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsExplicit.java new file mode 100644 index 0000000..7559fe9 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsExplicit.java @@ -0,0 +1,13 @@ +package ru.fusionsoft.dbgit.integration.primitives.args; + +import ru.fusionsoft.dbgit.integration.primitives.Args; + +public class ArgsExplicit implements Args { + private final CharSequence[] args; + public ArgsExplicit(CharSequence... values) { + this.args = values.clone(); + } + public final CharSequence[] values() { + return this.args; + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsLink.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsLink.java new file mode 100644 index 0000000..285e7e8 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsLink.java @@ -0,0 +1,32 @@ +package ru.fusionsoft.dbgit.integration.primitives.args; + +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalar; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalarOf; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; +import ru.fusionsoft.dbgit.integration.primitives.StickyScalar; + +public class ArgsLink implements Args { + + private final SafeScalar argsScalar; + + public ArgsLink(Scalar orign) { + this.argsScalar = new SafeScalarOf(new StickyScalar<>(orign)); + } + + @Override + public final CharSequence[] values() { + return argsScalar.value().values(); + } + public ArgsLink(String url, String database, String user, String pass) { + this(()-> { + return new ArgsExplicit( + "link", + url + "/" + database, + "user=" + user, + "password=" + pass + ); + }); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java new file mode 100644 index 0000000..f8bff8f --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java @@ -0,0 +1,31 @@ +package ru.fusionsoft.dbgit.integration.primitives.args; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; +import ru.fusionsoft.dbgit.integration.primitives.path.PathRelativeTo; + +public class ArgsRunningCommand extends ArgsExplicit { + public ArgsRunningCommand(CharSequence commandName) { + super( + System.getenv("ComSpec"), + "/C", + commandName + ); + } + public ArgsRunningCommand(Path executablePath) { + this( + new CharsOf<>( + Object::toString, + executablePath + ) + ); + } + public ArgsRunningCommand(Path executablePath, Path workingDirectory) { + this( + new PathRelativeTo( + workingDirectory, + executablePath + ) + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsWithAppend.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsWithAppend.java new file mode 100644 index 0000000..91964b0 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsWithAppend.java @@ -0,0 +1,27 @@ +package ru.fusionsoft.dbgit.integration.primitives.args; + +import org.apache.commons.lang3.ArrayUtils; +import ru.fusionsoft.dbgit.integration.primitives.Args; + +public class ArgsWithAppend implements Args { + private final Args origin; + private final Args append; + + public ArgsWithAppend(Args origin, Args append) { + this.origin = origin; + this.append = append; + } + + public ArgsWithAppend(Args origin, String... append) { + this.origin = origin; + this.append = new ArgsExplicit(append.clone()); + } + + @Override + public final CharSequence[] values() { + return ArrayUtils.addAll( + origin.values(), + append.values() + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsWithPrepend.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsWithPrepend.java new file mode 100644 index 0000000..b3f7b19 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsWithPrepend.java @@ -0,0 +1,26 @@ +package ru.fusionsoft.dbgit.integration.primitives.args; + +import org.apache.commons.lang3.ArrayUtils; +import ru.fusionsoft.dbgit.integration.primitives.Args; + +public class ArgsWithPrepend implements Args { + private final Args origin; + private final Args prepend; + + public ArgsWithPrepend(Args origin, Args prepend) { + this.origin = origin; + this.prepend = prepend; + } + public ArgsWithPrepend(Args origin, CharSequence... prepend) { + this.origin = origin; + this.prepend = new ArgsExplicit(prepend); + } + + @Override + public final CharSequence[] values() { + return ArrayUtils.addAll( + prepend.values(), + origin.values() + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java new file mode 100644 index 0000000..dfa64fc --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; + +public class AutoPgLinkArgs extends ArgsLink { + public AutoPgLinkArgs(String database) { + super(()->new LocalPgLinkArgs(database)); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/DedicatedPgLinkArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/DedicatedPgLinkArgs.java new file mode 100644 index 0000000..67c9cd1 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/DedicatedPgLinkArgs.java @@ -0,0 +1,27 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; +import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.PgCredentials; + +public class DedicatedPgLinkArgs extends ArgsLink { + public DedicatedPgLinkArgs(String database, String username, String password) { + super( + "jdbc:postgresql://135.181.94.98:31007/", + database, + username, + password + ); + } + + public DedicatedPgLinkArgs(String database, Credentials credentials) { + this(database, credentials.username(), credentials.password()); + } + + public DedicatedPgLinkArgs(String database) { + this( + database, + new PgCredentials() + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/GitTestRepoAddRemoteArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/GitTestRepoAddRemoteArgs.java new file mode 100644 index 0000000..7d05bb3 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/GitTestRepoAddRemoteArgs.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsDbGitAddRemote; +import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.GitTestRepoCredentials; + +public class GitTestRepoAddRemoteArgs extends ArgsDbGitAddRemote { + public GitTestRepoAddRemoteArgs(String url, String name, String user, String pass) { + super(url, name, user, pass); + } + public GitTestRepoAddRemoteArgs(String url, String name, Credentials credentials) { + this(url, name, credentials.username(), credentials.password()); + } + public GitTestRepoAddRemoteArgs(String name) { + this( + "https://github.com/rocket-3/dbgit-test.git", + name, + new GitTestRepoCredentials() + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/LocalPgLinkArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/LocalPgLinkArgs.java new file mode 100644 index 0000000..0b77876 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/LocalPgLinkArgs.java @@ -0,0 +1,23 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; +import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.PgCredentials; + +public class LocalPgLinkArgs extends ArgsLink { + public LocalPgLinkArgs(String database, String user, String pass) { + super( + "jdbc:postgresql://localhost", + database, + user, + pass + ); + + } + public LocalPgLinkArgs(String database, Credentials credentials) { + this(database, credentials.username(), credentials.password()); + } + public LocalPgLinkArgs(String database) { + this(database, new PgCredentials()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharSequenceEnvelope.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharSequenceEnvelope.java new file mode 100644 index 0000000..32db886 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharSequenceEnvelope.java @@ -0,0 +1,54 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.util.stream.IntStream; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; +import ru.fusionsoft.dbgit.integration.primitives.StickyScalar; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalar; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalarOf; + +public abstract class CharSequenceEnvelope implements CharSequence { + private final SafeScalar origin; + + private CharSequenceEnvelope(final SafeScalar origin) { + this.origin = origin; + } + + public CharSequenceEnvelope(final Scalar origin) { + this( + new SafeScalarOf<>( + new StickyScalar<>(origin) + ) + ); + } + + + @Override + public final int length() { + return origin.value().length(); + } + + @Override + public final char charAt(int i) { + return origin.value().charAt(i); + } + + @Override + public final CharSequence subSequence(int i, int i1) { + return origin.value().subSequence(i, i1); + } + + @Override + public final IntStream chars() { + return origin.value().chars(); + } + + @Override + public final IntStream codePoints() { + return origin.value().codePoints(); + } + + @Override + public final String toString() { + return origin.value().toString(); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOf.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOf.java new file mode 100644 index 0000000..20f20c1 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOf.java @@ -0,0 +1,15 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import ru.fusionsoft.dbgit.integration.primitives.Function; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; +import ru.fusionsoft.dbgit.integration.primitives.StickyScalar; + +public class CharsOf extends CharSequenceEnvelope { + public CharsOf(Function extraction, X source) { + super(new StickyScalar(extraction, source)); + } + + public CharsOf(Scalar scalar) { + super(new StickyScalar<>(scalar)); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CommitsFromRepo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CommitsFromRepo.java new file mode 100644 index 0000000..8099376 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CommitsFromRepo.java @@ -0,0 +1,51 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import com.google.common.collect.Lists; +import java.util.List; +import java.util.stream.Collectors; +import org.eclipse.jgit.api.Git; +import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription; +import org.eclipse.jgit.internal.storage.dfs.InMemoryRepository; +import org.eclipse.jgit.lib.AnyObjectId; +import org.eclipse.jgit.transport.RefSpec; + +public class CommitsFromRepo { + private final String repoUrl; + private final String branchName; + + public CommitsFromRepo(String repoUrl, String branchName) { + this.repoUrl = repoUrl; + this.branchName = branchName; + } + + public final List names() throws Exception { + final String treeName = "refs/heads/" + branchName; // tag or branch + try ( + final Git git = new Git( + new InMemoryRepository( + new DfsRepositoryDescription() + ) + ) + ) { + git.fetch() + .setRemote(repoUrl) + .setRefSpecs( + new RefSpec( + "+refs/heads/" + branchName + + ":refs/heads/" + branchName + ) + ) + .call(); + + return Lists.newArrayList( + git + .log() + .add(git.getRepository().resolve(treeName)) + .call() + ) + .stream() + .map(AnyObjectId::getName) + .collect(Collectors.toList()); + } + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbIgnoreDefaultChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbIgnoreDefaultChars.java new file mode 100644 index 0000000..68ebfe7 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbIgnoreDefaultChars.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +public class DbIgnoreDefaultChars extends CharSequenceEnvelope { + + public DbIgnoreDefaultChars() { + super(() -> { + return + "*\n" + + "!public/*.ts\n" + + "!public/*.sch\n" + + "!public/*.seq\n" + + "!public/*.tbl\n" + + "!public/*.pkg\n" + + "!public/*.trg\n" + + "!public/*.prc\n" + + "!public/*.fnc\n" + + "!public/*.vw\n" + + "!public/*.blob\n"; + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbLinkChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbLinkChars.java new file mode 100644 index 0000000..954de4b --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbLinkChars.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.text.MessageFormat; +import ru.fusionsoft.dbgit.integration.primitives.Credentials; + +public class DbLinkChars extends CharSequenceEnvelope { + public DbLinkChars(String url, String catalog, Credentials credentials) { + super(() -> { + return + MessageFormat.format( + "url=jdbc:postgresql://{0}/{1}\n" + + "user={2}\n" + + "password={3}\n" + , url + , catalog + , credentials.username() + , credentials.password() + ); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/InputStreamChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/InputStreamChars.java new file mode 100644 index 0000000..05d8d05 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/InputStreamChars.java @@ -0,0 +1,41 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.io.BufferedReader; +import java.io.InputStream; +import java.io.InputStreamReader; + +public class InputStreamChars extends CharSequenceEnvelope{ + public InputStreamChars(InputStream origin, String codepageName) { + super(() -> { + + try ( + final BufferedReader reader = new BufferedReader( + codepageName.equals("default") + ? new InputStreamReader(origin) + : new InputStreamReader(origin, codepageName) + ) + ) { + StringBuilder builder = new StringBuilder(); + String line = null; + while (( line = reader.readLine() ) != null) { + builder.append("> "); + builder.append(line); + builder.append(System.getProperty("line.separator")); + } + return builder.toString(); + } + +// try (final Scanner s = new Scanner(origin)) { +// final StringBuilder text = new StringBuilder(); +// while (s.hasNextLine()) text +// .append("\n> ") +// .append(s.nextLine()); +// return text.toString(); +// } + }); + } + + public InputStreamChars(InputStream origin) { + this(origin, "default"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/SavedConsoleText.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/SavedConsoleText.java new file mode 100644 index 0000000..8d81410 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/SavedConsoleText.java @@ -0,0 +1,69 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.io.ByteArrayOutputStream; +import java.io.OutputStream; +import java.io.PrintStream; +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import ru.fusionsoft.dbgit.integration.primitives.RunnableWithException; + +public class SavedConsoleText { + private final RunnableWithException runnable; + + public SavedConsoleText(RunnableWithException runnable) { + this.runnable = runnable; + } + + public final String text() throws Exception{ + final PrintStream original = System.out; + try (final ByteArrayOutputStream cachedOutputStream = new ByteArrayOutputStream();) { + try { + + System.setOut(new PrintStream( + cachedOutputStream, + true, + "UTF-8" + )); + + runnable.run(); + return cachedOutputStream.toString(); + + } catch (RuntimeException e) { + final Throwable cause = e.getCause() != null ? e.getCause() : e; + throw new RuntimeException( + "Runtime exception occurred while catching this console output:\n" + + cachedOutputStream.toString(), + e + ); + } catch (Exception e) { + throw new Exception( + "Exception occurred while catching this console output:\n" + + cachedOutputStream.toString(), + e + ); + } catch (AssertionError e) { + final Throwable cause = e.getCause() != null ? e.getCause() : e; + throw new Error( + "Assertion failed while catching this console output:\n" + + cachedOutputStream.toString(), + e + ); + } catch (Error e) { + final Throwable cause = e.getCause() != null ? e.getCause() : e; + throw new Error( + "Error occurred while catching this console output:\n" + + cachedOutputStream.toString(), + e + ); + } finally { + System.setOut(original); + } + } + } + + public final List lines() throws Exception{ + return Arrays.asList(this.text().split("\\n")); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultDetailedChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultDetailedChars.java new file mode 100644 index 0000000..17fefcb --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultDetailedChars.java @@ -0,0 +1,44 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.text.MessageFormat; +import java.util.concurrent.atomic.AtomicBoolean; +import org.junit.platform.commons.util.ExceptionUtils; +import ru.fusionsoft.dbgit.integration.primitives.Test; + +public class TestResultDetailedChars extends CharsOf { + + public TestResultDetailedChars(Subject subject, Test test) { + super( + () -> { + CharSequence details; + CharSequence successMarkChars; + + try { + final AtomicBoolean value = new AtomicBoolean(false); + details = new SavedConsoleText( + () -> { + value.set(test.value(subject)); + } + ).text(); + successMarkChars = new TestSuccessMarkChars(value.get()); + + } catch (Error e) { + details = ExceptionUtils.readStackTrace(e.getCause()); + successMarkChars = new TestSuccessMarkChars(e); + } catch (RuntimeException e) { + details = ExceptionUtils.readStackTrace(e.getCause()); + successMarkChars = new TestSuccessMarkChars(e); + } catch (Exception e) { + details = ExceptionUtils.readStackTrace(e.getCause()); + successMarkChars = new TestSuccessMarkChars(e); + } + return MessageFormat.format( + "{0} {1}\n{2}", + successMarkChars, + test.description(), + details + ); + } + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultShortChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultShortChars.java new file mode 100644 index 0000000..ecfb21d --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultShortChars.java @@ -0,0 +1,16 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import ru.fusionsoft.dbgit.integration.primitives.Test; + +public class TestResultShortChars extends CharsOf { + public TestResultShortChars(Subject subject, Test test) { + super( + () -> { + return String.valueOf( + new TestResultDetailedChars<>(subject, test) + ) + .split("\n")[0]; + } + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestSuccessMarkChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestSuccessMarkChars.java new file mode 100644 index 0000000..0492f5e --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestSuccessMarkChars.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +public class TestSuccessMarkChars extends CharSequenceEnvelope { + + public TestSuccessMarkChars(boolean booleanValue) { + super(()-> booleanValue ? "[TEST OK]" : "[TEST FAIL]"); + } + + public TestSuccessMarkChars(Exception testException) { + super(()-> "[TEST RUNNING EXCEPTION]"); + } + + public TestSuccessMarkChars(Error subjectConstructionError ) { + super(() -> "[TEST SUBJECT ERROR]"); + } + + public TestSuccessMarkChars(RuntimeException subjectConstructionRuntimeException ) { + super(() -> "[TEST SUBJECT ERROR]"); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsEnvelope.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsEnvelope.java new file mode 100644 index 0000000..638e961 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsEnvelope.java @@ -0,0 +1,25 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalar; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalarOf; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; +import ru.fusionsoft.dbgit.integration.primitives.StickyScalar; + +public class CredentialsEnvelope implements Credentials { + private final SafeScalar credentialsScalar; + + public CredentialsEnvelope(Scalar credentialsScalar) { + this.credentialsScalar = new SafeScalarOf<>(new StickyScalar<>(credentialsScalar)); + } + + @Override + public final String username() { + return this.credentialsScalar.value().username(); + } + + @Override + public final String password() { + return this.credentialsScalar.value().password(); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromFileCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromFileCredentials.java new file mode 100644 index 0000000..9f34c09 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromFileCredentials.java @@ -0,0 +1,16 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.files.FileContent; + +public class FromFileCredentials extends CredentialsEnvelope { + + public FromFileCredentials(Path secretFilePath) { + super(()-> { + final String[] lines = new FileContent(secretFilePath) + .text() + .split("\n"); + return new SimpleCredentials(lines[0],lines[1]); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromPropertiesCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromPropertiesCredentials.java new file mode 100644 index 0000000..3521a2b --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromPropertiesCredentials.java @@ -0,0 +1,14 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials; + +public class FromPropertiesCredentials extends CredentialsEnvelope { + public FromPropertiesCredentials(String usrPropName, String pwdPropName) { + super(()-> { + final String usrValue = System.getProperty(usrPropName); + final String pwdValue = System.getProperty(pwdPropName); + if (usrValue == null || usrValue.isEmpty() || pwdValue == null || pwdValue.isEmpty()) { + throw new Exception("Could not obtain credentials from props"); + } + return new SimpleCredentials(usrValue, pwdValue); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/SimpleCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/SimpleCredentials.java new file mode 100644 index 0000000..bdd2006 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/SimpleCredentials.java @@ -0,0 +1,24 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; + +public class SimpleCredentials implements Credentials { + + private final String username; + private final String password; + + public SimpleCredentials(String username, String password) { + this.username = username; + this.password = password; + } + + @Override + public final String username() { + return this.username; + } + + @Override + public final String password() { + return this.password; + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoCredentials.java new file mode 100644 index 0000000..a0885b4 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoCredentials.java @@ -0,0 +1,25 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.credentials.CredentialsEnvelope; +import ru.fusionsoft.dbgit.integration.primitives.credentials.SimpleCredentials; + +public class GitTestRepoCredentials extends CredentialsEnvelope { + public GitTestRepoCredentials() { + super(() -> { + try { + final Credentials creds = new GitTestRepoPropsCredentials(); + return new SimpleCredentials( + creds.username(), + creds.password() + ); + } catch (Throwable e) { + final Credentials creds = new GitTestRepoFileCredentials(); + return new SimpleCredentials( + creds.username(), + creds.password() + ); + } + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoFileCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoFileCredentials.java new file mode 100644 index 0000000..c637e39 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoFileCredentials.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; + +import ru.fusionsoft.dbgit.integration.primitives.credentials.FromFileCredentials; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; + +public class GitTestRepoFileCredentials extends FromFileCredentials { + public GitTestRepoFileCredentials() { + super(new CurrentWorkingDirectory().resolve("../gitSecret.txt")); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoPropsCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoPropsCredentials.java new file mode 100644 index 0000000..97ebb4b --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoPropsCredentials.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; + +import ru.fusionsoft.dbgit.integration.primitives.credentials.FromPropertiesCredentials; + +public class GitTestRepoPropsCredentials extends FromPropertiesCredentials { + public GitTestRepoPropsCredentials() { + super("gitUser", "gitPass"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgCredentials.java new file mode 100644 index 0000000..cdf4d0e --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgCredentials.java @@ -0,0 +1,25 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.credentials.CredentialsEnvelope; +import ru.fusionsoft.dbgit.integration.primitives.credentials.SimpleCredentials; + +public class PgCredentials extends CredentialsEnvelope { + public PgCredentials() { + super(() -> { + try { + final Credentials creds = new PgPropsCredentials(); + return new SimpleCredentials( + creds.username(), + creds.password() + ); + } catch (Throwable e) { + final Credentials creds = new PgFileCredentials(); + return new SimpleCredentials( + creds.username(), + creds.password() + ); + } + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgFileCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgFileCredentials.java new file mode 100644 index 0000000..b8b4973 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgFileCredentials.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; + +import ru.fusionsoft.dbgit.integration.primitives.credentials.FromFileCredentials; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; + +public class PgFileCredentials extends FromFileCredentials { + public PgFileCredentials() { + super(new CurrentWorkingDirectory().resolve("../pgSecret.txt")); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgPropsCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgPropsCredentials.java new file mode 100644 index 0000000..26b1501 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgPropsCredentials.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; + +import ru.fusionsoft.dbgit.integration.primitives.credentials.FromPropertiesCredentials; + +public class PgPropsCredentials extends FromPropertiesCredentials { + public PgPropsCredentials() { + super("pgUser", "pgPass"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/DbGitMetaFiles.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/DbGitMetaFiles.java new file mode 100644 index 0000000..61ebac4 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/DbGitMetaFiles.java @@ -0,0 +1,47 @@ +package ru.fusionsoft.dbgit.integration.primitives.files; + + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class DbGitMetaFiles implements TextResourceGroup { + private final Path workingDirectory; + + public DbGitMetaFiles(Path workingDirectory) { + this.workingDirectory = workingDirectory; + } + + @Override + public final void add(String name, String content) throws IOException { + new FileContent(this.workingDirectory, name).updateText(content); + } + + @Override + public final void clean() throws IOException { + for (TextResource textFile : this.all().values()) { + textFile.delete(); + } + } + + @Override + public final TextResource file(String... name){ + return new FileContent(this.workingDirectory, name); +} + + @Override + public final Map all() throws IOException { + try (Stream paths = Files.walk(this.workingDirectory.resolve(".dbgit"))) { + return paths + .filter( x->x.getParent().getParent().toFile().getName().equals(".dbgit") ) + .filter(Files::isRegularFile ) + .peek(System.out::println) + .collect(Collectors.toMap( x->x.toFile().getName(), FileContent::new) ); + } + } + + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/FileContent.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/FileContent.java new file mode 100644 index 0000000..d9edd6d --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/FileContent.java @@ -0,0 +1,43 @@ +package ru.fusionsoft.dbgit.integration.primitives.files; + +import org.apache.commons.io.FileUtils; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Path; + +public class FileContent implements TextResource { + private final File file; + + public FileContent(final File file) { + this.file = file; + } + + public FileContent(final Path path) { + this(path.toFile()); + } + + public FileContent(final Path workingDirectory, final String... name) { + this(workingDirectory.resolve(String.join("//", name))); + } + + @Override + public final String text() throws IOException { + return FileUtils.readFileToString(this.file); + } + + @Override + public final TextResource updateText(final String content) throws IOException { + this.file.getParentFile().mkdirs(); + FileUtils.writeStringToFile(this.file, content); + return this; + } + + @Override + public final TextResource delete() throws IOException { + if (this.file.exists()) { + FileUtils.forceDelete(this.file); + } + return this; + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextFileTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextFileTest.java new file mode 100644 index 0000000..c148387 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextFileTest.java @@ -0,0 +1,56 @@ +package ru.fusionsoft.dbgit.integration.primitives.files; + +import org.apache.commons.io.FileUtils; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Path; + +public class TextFileTest { + + private final Path path; + + public TextFileTest(Path path) { + this.path = path; + } + + public TextFileTest() { + this(new CurrentWorkingDirectory()); + } + + @Test + public void createsFile() throws IOException { + String relativePath = ".dbgit/.dblink"; + + Assertions.assertEquals( + new FileContent(this.path, relativePath) + .updateText("ABC") + .text(), + + FileUtils.readFileToString( + this.path.resolve(relativePath).toFile() + ) + ); + } + + @Test + public void updatesContent() throws IOException { + File file = this.path.resolve("file").toFile(); + String content = "CBD"; + + new FileContent(file).updateText(content); + + Assertions.assertEquals( + content, + FileUtils.readFileToString(file) + ); + } + + @Test + public void pathTest() { + System.out.println(); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextResource.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextResource.java new file mode 100644 index 0000000..a7f16fb --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextResource.java @@ -0,0 +1,11 @@ +package ru.fusionsoft.dbgit.integration.primitives.files; + + +import java.io.IOException; + +public interface TextResource { + String text() throws IOException; + TextResource updateText(String content) throws IOException; + TextResource delete() throws IOException; + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextResourceGroup.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextResourceGroup.java new file mode 100644 index 0000000..cbf5b88 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/TextResourceGroup.java @@ -0,0 +1,11 @@ +package ru.fusionsoft.dbgit.integration.primitives.files; + +import java.io.IOException; +import java.util.Map; + +public interface TextResourceGroup { + void add(String name, String content) throws IOException; + void clean() throws IOException; + TextResource file(String... name); + Map all() throws IOException; +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCloningGitRepo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCloningGitRepo.java new file mode 100644 index 0000000..b2f4673 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCloningGitRepo.java @@ -0,0 +1,42 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequental; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; + +public class PathPatchCloningGitRepo extends PatchSequental { + + public PathPatchCloningGitRepo(final String repoUrl, final String branchName, PrintStream printStream) { + super( + new PathPatchRunningProcessFrom( + new ArgsExplicit( + System.getenv("ComSpec"), + "/C", + "git", + "clone", + repoUrl, + "." + ), + printStream + ), + new PathPatchRunningProcessFrom( + new ArgsExplicit( + System.getenv("ComSpec"), + "/C", + "git", + "reset", + "--hard", + branchName + ), + printStream + ) + + ); + } + + public PathPatchCloningGitRepo(final String repoUrl, final String branchName) { + this(repoUrl, branchName, new NullPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchConfiguringDbGit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchConfiguringDbGit.java new file mode 100644 index 0000000..9405721 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchConfiguringDbGit.java @@ -0,0 +1,18 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequental; + +public class PathPatchConfiguringDbGit extends PatchSequental { + + public PathPatchConfiguringDbGit(final String linkContent, final String ignoreContent, final String configContent, final String indexContent) { + super( + new PathPatchCreatingFile(".dbgit/.dblink", linkContent), + new PathPatchCreatingFile(".dbgit/.dbignore", ignoreContent), + new PathPatchCreatingFile(".dbgit/.dbindex", indexContent), + new PathPatchCreatingFile(".dbgit/dbgitconfig", configContent) + ); + + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCreatingFile.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCreatingFile.java new file mode 100644 index 0000000..a7ba0a8 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCreatingFile.java @@ -0,0 +1,23 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.File; +import java.nio.file.Path; +import org.apache.commons.io.FileUtils; +import ru.fusionsoft.dbgit.integration.primitives.Patch; + +public class PathPatchCreatingFile implements Patch { + private final String name; + private final String content; + + public PathPatchCreatingFile(final String name, final CharSequence content) { + this.name = name; + this.content = String.valueOf(content); + } + + @Override + public final void apply(final Path root) throws Exception { + final File file = root.resolve(this.name).toFile(); + file.getParentFile().mkdirs(); + FileUtils.writeStringToFile(file, this.content); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchDeletingFiles.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchDeletingFiles.java new file mode 100644 index 0000000..5400d90 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchDeletingFiles.java @@ -0,0 +1,30 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.File; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Collection; +import org.apache.commons.io.FileUtils; +import ru.fusionsoft.dbgit.integration.primitives.Patch; + +public class PathPatchDeletingFiles implements Patch { + private final Collection names; + + private PathPatchDeletingFiles(Collection names) { + this.names = names; + } + + public PathPatchDeletingFiles(String... names) { + this(Arrays.asList(names)); + } + + @Override + public final void apply(Path root) throws Exception { + for (String name : this.names) { + final File file = root.resolve(name).toFile(); + if (file.exists()) { + FileUtils.forceDelete(file); + } + } + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchDeletingFilesWildcard.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchDeletingFilesWildcard.java new file mode 100644 index 0000000..aee125f --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchDeletingFilesWildcard.java @@ -0,0 +1,26 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.File; +import java.io.FileFilter; +import java.io.FilenameFilter; +import java.nio.file.Path; +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.filefilter.WildcardFileFilter; +import ru.fusionsoft.dbgit.integration.primitives.Patch; + +public class PathPatchDeletingFilesWildcard implements Patch { + private final FileFilter wildcardFileFilter; + + public PathPatchDeletingFilesWildcard(String mask) { + this.wildcardFileFilter = new WildcardFileFilter(mask); + } + + @Override + public final void apply(Path root) throws Exception { + final File[] files = root.toFile().listFiles((FilenameFilter) wildcardFileFilter); + if(files != null) + for (final File file : files) { + FileUtils.forceDelete(file); + } + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGitFrom.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGitFrom.java new file mode 100644 index 0000000..cfdd872 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGitFrom.java @@ -0,0 +1,46 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsRunningCommand; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithAppend; +import ru.fusionsoft.dbgit.integration.primitives.path.PathOfBuiltDbGitExecutable; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; + +public class PathPatchRunningDbGitFrom extends PathPatchRunningProcessFrom { + public PathPatchRunningDbGitFrom(Args args, Path executablePath, PrintStream printStream) { + super( + new ArgsWithAppend( + new ArgsRunningCommand(executablePath), + args + ), + printStream + ); + } + + public PathPatchRunningDbGitFrom(Args args, Path executablePath) { + this( + args, + executablePath, + System.out + ); + } + + public PathPatchRunningDbGitFrom(Args args, PrintStream printStream) { + this( + args, + new PathOfBuiltDbGitExecutable(new CurrentWorkingDirectory()), + printStream + ); + } + + public PathPatchRunningDbGitFrom(Args args) { + this( + args, + System.out + ); + } + + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java new file mode 100644 index 0000000..c1da387 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java @@ -0,0 +1,86 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.nio.file.Path; +import java.text.MessageFormat; +import java.util.Arrays; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.Patch; +import ru.fusionsoft.dbgit.integration.primitives.chars.InputStreamChars; + +public class PathPatchRunningProcessFrom implements Patch { + + private final Args processRunCommandLine; + private final PrintStream printStream; + + public PathPatchRunningProcessFrom(Args processRunCommandLine, PrintStream printStream) { + this.processRunCommandLine = processRunCommandLine; + this.printStream = printStream; + } + +// public PathPatchRunningProcessFrom(Args processRunCommandLine) { +// this.processRunCommandLine = processRunCommandLine; +// this.printStream = System.out; +// } + + @Override + public final void apply(Path root) throws Exception { + try ( + final ByteArrayOutputStream cachedOutputStream = new ByteArrayOutputStream(); + final PrintStream cachedPrintStream = new PrintStream( + cachedOutputStream, + true, + "UTF-8" + ) + ) { + final Consumer outputConsumer = (chars) -> { + cachedPrintStream.println(chars); + printStream.println(chars); + }; + + outputConsumer.accept(MessageFormat.format( + "{0} # {1}", + root.toString(), + String.join(" ", processRunCommandLine.values()) + )); + + final Process process = new ProcessBuilder() + .directory(root.toAbsolutePath().toFile()) + .command( + Arrays.stream(processRunCommandLine.values()) + .map(String::valueOf) + .collect(Collectors.toList()) + ) + .start(); + + final CharSequence processOutput = String.valueOf(new InputStreamChars( + process.getInputStream() + )); + final CharSequence processErrOutput = new InputStreamChars( + process.getErrorStream(), "Cp866" + ); + + final int exitCode = process.waitFor(); + process.destroyForcibly(); + outputConsumer.accept(processOutput); + + if (exitCode != 0) { + throw new RuntimeException(MessageFormat.format( + "Process exited with error, code {0}" + + "\nErrors: {1}" + + "\nOriginal output: {2}" + ,exitCode + ,processErrOutput.length() != 0 + ? "\n" + processErrOutput + : "...error stream was empty" + ,cachedOutputStream.size() != 0 + ? "\n" + cachedOutputStream.toString() + : "...output stream was empty" + )); + } + } + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterCommandRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterCommandRun.java new file mode 100644 index 0000000..f409fa8 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterCommandRun.java @@ -0,0 +1,24 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.io.OutputStream; +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningProcessFrom; + +public class PathAfterCommandRun extends PathPatched { + +// public PathAfterCommandRun(Args processRunCommandLine, Path origin) { +// super( +// origin, +// new PathPatchRunningProcessFrom(processRunCommandLine) +// ); +// } + + public PathAfterCommandRun(Args processRunCommandLine, PrintStream printStream, Path origin) { + super( + origin, + new PathPatchRunningProcessFrom(processRunCommandLine, printStream) + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRestore.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRestore.java new file mode 100644 index 0000000..408f642 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRestore.java @@ -0,0 +1,42 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsCheckoutNodb; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; + +public class PathAfterDbGitRestore extends PathAfterDbGitRun { + + public PathAfterDbGitRestore(ArgsCheckoutNodb checkoutArgs, ArgsLink linkArgs, Path dbGitExecutablePath, PrintStream printStream, Path dbGitRepo) { + super( + new ArgsExplicit("restore", "-r"), + dbGitExecutablePath, + printStream, + new PathWithDbGitCheckoutAndLink( + checkoutArgs, + linkArgs, + printStream, + dbGitRepo + ) + ); + } + + public PathAfterDbGitRestore(ArgsCheckoutNodb checkoutArgs, ArgsLink linkArgs, Path dbGitExecutablePath, Path dbGitRepo) { + this(checkoutArgs, linkArgs, dbGitExecutablePath, new NullPrintStream(), dbGitRepo); + } + + + public PathAfterDbGitRestore(ArgsCheckoutNodb checkoutArgs, ArgsLink linkArgs, Path dbGitRepo) { + this( + checkoutArgs, + linkArgs, + new CurrentWorkingDirectory(), + dbGitRepo + ); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRun.java new file mode 100644 index 0000000..63d5dfe --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRun.java @@ -0,0 +1,48 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsRunningCommand; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithAppend; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; + +public class PathAfterDbGitRun extends PathAfterCommandRun { + public PathAfterDbGitRun(Args args, Path executablePath, PrintStream printStream, Path workingDirectory) { + super( + new ArgsWithAppend( + new ArgsRunningCommand(executablePath, workingDirectory), + args + ), + printStream, + workingDirectory + ); + } + + public PathAfterDbGitRun(Args args, PrintStream printStream, Path workingDirectory) { + this( + args, + new PathOfBuiltDbGitExecutable(new CurrentWorkingDirectory()), + printStream, + workingDirectory + ); + } + + public PathAfterDbGitRun(Args args, Path executablePath, Path workingDirectory) { + this( + args, + executablePath, + new NullPrintStream(), + workingDirectory + ); + } + + public PathAfterDbGitRun(Args args, Path workingDirectory) { + this( + args, + new PathOfBuiltDbGitExecutable(new CurrentWorkingDirectory()), + workingDirectory + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathEnvelope.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathEnvelope.java new file mode 100644 index 0000000..437eb2d --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathEnvelope.java @@ -0,0 +1,160 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import ru.fusionsoft.dbgit.integration.primitives.Scalar; +import ru.fusionsoft.dbgit.integration.primitives.StickyScalar; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalar; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalarOf; + +import java.io.File; +import java.io.IOException; +import java.net.URI; +import java.nio.file.*; +import java.util.Iterator; + +public abstract class PathEnvelope implements Path { + + private final SafeScalar origin; + + public PathEnvelope(Scalar origin) { + this.origin = new SafeScalarOf<>( + new StickyScalar<>( + origin + ) + ); + } + + @Override + public String toString() { + return this.origin.value().toString(); + } + + @Override + public final FileSystem getFileSystem() { + return this.origin.value().getFileSystem(); + } + + @Override + public final boolean isAbsolute() { + return this.origin.value().isAbsolute(); + } + + @Override + public final Path getRoot() { + return this.origin.value().getRoot(); + } + + @Override + public final Path getFileName() { + return this.origin.value().getFileName(); + } + + @Override + public final Path getParent() { + return this.origin.value().getParent(); + } + + @Override + public final int getNameCount() { + return this.origin.value().getNameCount(); + } + + @Override + public final Path getName(int i) { + return this.origin.value().getName(i); + } + + @Override + public final Path subpath(int i, int i1) { + return this.origin.value().subpath(i, i1); + } + + @Override + public final boolean startsWith(Path path) { + return this.origin.value().startsWith(path); + } + + @Override + public final boolean endsWith(Path path) { + return this.origin.value().endsWith(path); + } + + @Override + public final Path normalize() { + return this.origin.value().normalize(); + } + + @Override + public final Path resolve(Path path) { + return this.origin.value().resolve(path); + } + + @Override + public final Path relativize(Path path) { + return this.origin.value().relativize(path); + } + + @Override + public final URI toUri() { + return this.origin.value().toUri(); + } + + @Override + public final Path toAbsolutePath() { + return this.origin.value().toAbsolutePath(); + } + + @Override + public final Path toRealPath(LinkOption... linkOptions) throws IOException { + return this.origin.value().toRealPath(linkOptions); + } + + @Override + public final WatchKey register(WatchService watchService, WatchEvent.Kind[] kinds, WatchEvent.Modifier... modifiers) throws IOException { + return this.origin.value().register(watchService,kinds,modifiers); + } + + @Override + public final int compareTo(Path path) { + return this.origin.value().compareTo(path); + } + + @Override + public final Iterator iterator() { + return origin.value().iterator(); + } + + @Override + public final WatchKey register(WatchService watcher, WatchEvent.Kind... events) throws IOException { + return this.origin.value().register(watcher, events); + } + + @Override + public final boolean startsWith(String other) { + return this.origin.value().startsWith(other); + } + + @Override + public final boolean endsWith(String other) { + return this.origin.value().endsWith(other); + } + + @Override + public final Path resolve(String other) { + return this.origin.value().resolve(other); + } + + @Override + public final Path resolveSibling(Path other) { + return this.origin.value().resolveSibling(other); + } + + @Override + public final Path resolveSibling(String other) { + return this.origin.value().resolveSibling(other); + } + + @Override + public final File toFile() { + return this.origin.value().toFile(); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathNotProjectRoot.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathNotProjectRoot.java new file mode 100644 index 0000000..9bcbf6b --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathNotProjectRoot.java @@ -0,0 +1,30 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + + +import java.nio.file.Path; + +public class PathNotProjectRoot extends PathEnvelope{ + public PathNotProjectRoot(Path origin) { + super(()-> { + if( + origin.resolve(".git").toFile().exists() && + origin.resolve("pom.xml").toFile().exists() + ){ + throw new PathIsProjectRootException(origin); + } + return origin; + }); + } + + private static class PathIsProjectRootException extends RuntimeException { + PathIsProjectRootException(Path path) { + super( + "\nGiven path " + path.toString() + " " + + "points to a project root directory.\n" + + "I'm here not to allow that." + ); + } + } +} + + diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOf.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOf.java new file mode 100644 index 0000000..617b5e2 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOf.java @@ -0,0 +1,15 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; + +public class PathOf extends PathEnvelope { + + public PathOf(Scalar origin) { + super(origin); + } + + public PathOf(String path, Path origin) { + super(()->origin.resolve(path)); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOfBuiltDbGitExecutable.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOfBuiltDbGitExecutable.java new file mode 100644 index 0000000..10fc080 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOfBuiltDbGitExecutable.java @@ -0,0 +1,12 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.nio.file.Path; + +public class PathOfBuiltDbGitExecutable extends PathOf { + public PathOfBuiltDbGitExecutable(Path dbGitProjectPath) { + super( + "target/dbgit/bin/dbgit", + dbGitProjectPath + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPatched.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPatched.java new file mode 100644 index 0000000..9cb38a2 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPatched.java @@ -0,0 +1,14 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Patch; +import ru.fusionsoft.dbgit.integration.primitives.PatchedScalar; + +public class PathPatched extends PathEnvelope { + + public PathPatched(final Path origin, final Patch patch) { + super( + new PatchedScalar<>(origin, patch) + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPrintsToConsole.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPrintsToConsole.java new file mode 100644 index 0000000..2f2f4f0 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPrintsToConsole.java @@ -0,0 +1,26 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.nio.file.Path; +import java.util.Arrays; +import java.util.stream.Collectors; + + +public class PathPrintsToConsole extends PathEnvelope { + + public PathPrintsToConsole(String text, Path origin) { + super(() -> { + System.out.println(text); + return origin; + }); + } + public PathPrintsToConsole(Path origin) { + this( + "--> " + origin.toAbsolutePath() + + Arrays + .stream(origin.toFile().listFiles()) + .map( file -> file.getName() + (file.isDirectory() ? " (dir) " : "") ) + .collect(Collectors.joining("\n")), + origin + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathRelativeTo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathRelativeTo.java new file mode 100644 index 0000000..9c41733 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathRelativeTo.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.nio.file.Path; +import java.nio.file.Paths; + +public class PathRelativeTo extends PathEnvelope { + public PathRelativeTo(Path to, Path origin) { + super(()-> { + return Paths.get( + to + .toAbsolutePath() + .toString() + ) + .relativize(Paths.get( + origin + .toAbsolutePath() + .toString() + )); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithBuildingDbGitExecutableFromGit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithBuildingDbGitExecutableFromGit.java new file mode 100644 index 0000000..708011e --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithBuildingDbGitExecutableFromGit.java @@ -0,0 +1,59 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequental; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithPrepend; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCloningGitRepo; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFiles; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFilesWildcard; + +public class PathWithBuildingDbGitExecutableFromGit extends PathEnvelope { + + public PathWithBuildingDbGitExecutableFromGit(String commitHash, PrintStream printStream, Path origin) { + super(() -> { + + return new PathOfBuiltDbGitExecutable( + new PathAfterCommandRun( + new ArgsWithPrepend( + new ArgsExplicit( + "mvn", + "package", + "appassembler:assemble", + "-D", + "skipTests" + ), + new ArgsExplicit( + System.getenv("ComSpec"), + "/C" + ) + ), + printStream, + new PathPatched( + new PathNotProjectRoot(origin), + new PatchSequental( + new PathPatchDeletingFilesWildcard( + "*" + ), + new PathPatchCloningGitRepo( + "https://github.com/databasegit/dbgit.git", + commitHash, + printStream + ), + new PathPatchDeletingFiles( + "src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java" + ) + ) + ) + ) + ); + + }); + } + + public PathWithBuildingDbGitExecutableFromGit(String commitHash, Path origin) { + this(commitHash, new NullPrintStream(), origin); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitCheckoutAndLink.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitCheckoutAndLink.java new file mode 100644 index 0000000..8633ee5 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitCheckoutAndLink.java @@ -0,0 +1,33 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsCheckoutNodb; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; + +public class PathWithDbGitCheckoutAndLink extends PathAfterDbGitRun { + public PathWithDbGitCheckoutAndLink( + ArgsCheckoutNodb checkoutArgs, + ArgsLink linkArgs, + PrintStream printStream, + Path origin + ) { + super( + linkArgs, + printStream, + new PathAfterDbGitRun( + checkoutArgs, + origin + ) + ); + } + + public PathWithDbGitCheckoutAndLink( + ArgsCheckoutNodb checkoutArgs, + ArgsLink linkArgs, + Path origin + ) { + this(checkoutArgs, linkArgs, new NullPrintStream(), origin); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitRepoInitialized.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitRepoInitialized.java new file mode 100644 index 0000000..c1d27ae --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitRepoInitialized.java @@ -0,0 +1,29 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; + +public class PathWithDbGitRepoInitialized extends PathAfterDbGitRun { + public PathWithDbGitRepoInitialized(CharSequence repoUrl, Path origin) { + super( + new ArgsExplicit("init"), + + new PathAfterDbGitRun( + new ArgsExplicit( + "clone", + repoUrl, + "--directory", + "\"" + origin.toAbsolutePath().toString() + "\"" + ), + + new PathWithoutFiles( + "*", + new PathNotProjectRoot( + origin + ) + ) + + ) + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithFiles.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithFiles.java new file mode 100644 index 0000000..026080a --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithFiles.java @@ -0,0 +1,22 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; + +public class PathWithFiles extends PathEnvelope { + public PathWithFiles(PathPatchCreatingFile[] filePatches, Path origin) { + super(new Scalar() { + @Override + public Path value() throws Exception { + for (final PathPatchCreatingFile filePatch : filePatches) { + filePatch.apply(origin); + } + return origin; + } + }); + } + public PathWithFiles(PathPatchCreatingFile file, Path origin){ + this(new PathPatchCreatingFile[]{file}, origin); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithoutFiles.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithoutFiles.java new file mode 100644 index 0000000..210eb9f --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithoutFiles.java @@ -0,0 +1,26 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFiles; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFilesWildcard; + +public class PathWithoutFiles extends PathEnvelope { + + public PathWithoutFiles(String[] names, Path origin) { + super( + () -> { + new PathPatchDeletingFiles(names).apply(origin); + return origin; + } + ); + } + + public PathWithoutFiles(String filterMask, Path origin) { + super( + () -> { + new PathPatchDeletingFilesWildcard(filterMask).apply(origin); + return origin; + } + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/CurrentWorkingDirectory.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/CurrentWorkingDirectory.java new file mode 100644 index 0000000..f46b366 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/CurrentWorkingDirectory.java @@ -0,0 +1,12 @@ +package ru.fusionsoft.dbgit.integration.primitives.path.specific; + +import java.nio.file.Paths; +import ru.fusionsoft.dbgit.integration.primitives.path.PathEnvelope; + +public class CurrentWorkingDirectory extends PathEnvelope { + public CurrentWorkingDirectory(){ + super(()-> { + return Paths.get(""); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/ProjectTestResourcesCleanDirectoryPath.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/ProjectTestResourcesCleanDirectoryPath.java new file mode 100644 index 0000000..9437152 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/ProjectTestResourcesCleanDirectoryPath.java @@ -0,0 +1,32 @@ +package ru.fusionsoft.dbgit.integration.primitives.path.specific; + +import java.io.File; +import java.util.concurrent.ThreadLocalRandom; +import org.apache.commons.io.FileUtils; +import ru.fusionsoft.dbgit.integration.primitives.path.PathEnvelope; + +public class ProjectTestResourcesCleanDirectoryPath extends PathEnvelope { + + public ProjectTestResourcesCleanDirectoryPath() { + this( + String.format( + "%#X", + ThreadLocalRandom.current().nextInt( + 0, + 32 + ) + ) + ); + } + + public ProjectTestResourcesCleanDirectoryPath(String name) { + super(() -> { + final File directory = new File( + "target/itoutput/" + name + ); + directory.mkdirs(); + FileUtils.cleanDirectory(directory); + return directory.toPath(); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java b/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java index 0a7a0be..2db84ff 100644 --- a/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssqlTest.java @@ -19,6 +19,7 @@ @Tag("mssqlTest") +@Tag("deprecated") public class DBAdapterMssqlTest { public static Properties testProps; @@ -31,7 +32,7 @@ public class DBAdapterMssqlTest { * Setup of ip an ports via SQLServerManager11.msc also needed, mine was: * Protocols -> SQL EXPRESS protocols -> Protocol -> Listen all to true and * Protocols -> SQL EXPRESS protocols -> Protocol -> IP adresses -> IPAll -> TCP Port to 1433 and Dynamic TCP Port to blank - * */ + */ public static String TEST_CONN_URL = "23.105.226.179:1433"; public static String TEST_CONN_CATALOG = "testdatabasegit"; @@ -1520,4 +1521,4 @@ private void dropTestTriggerProcedureFunctions(String tableName) throws Exceptio ); stmt.close(); } -} \ No newline at end of file +} diff --git a/src/test/resources/repo b/src/test/resources/repo deleted file mode 160000 index 8867384..0000000 --- a/src/test/resources/repo +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 88673845e9891228d2ebb7ad3bdebb534ce8efbe From e3330ad7c6816056931df23ed8a3b5b05f665985 Mon Sep 17 00:00:00 2001 From: rocket Date: Thu, 13 May 2021 21:11:44 +0300 Subject: [PATCH 46/68] Switched to usage of dedicated database link in IT --- .../integration/primitives/args/specific/AutoPgLinkArgs.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java index dfa64fc..821df06 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java @@ -4,7 +4,7 @@ public class AutoPgLinkArgs extends ArgsLink { public AutoPgLinkArgs(String database) { - super(()->new LocalPgLinkArgs(database)); + super(()->new DedicatedPgLinkArgs(database)); } } From d1e1942f7c94e71ae90fae95e301568fd7499c39 Mon Sep 17 00:00:00 2001 From: rocket Date: Tue, 25 May 2021 03:20:51 +0300 Subject: [PATCH 47/68] IT engine refactor IT add basic scenarios in DbGitIntegrationTestBasic IT add runnable tests excluded by default for IT environment workaround in DbGitIntegrationTestNotebook Fix of App.java lifecycle and exception handling - now in one place and writes errors to System.err stream Fix of error with DBAdapterPostgres.getTable on pg 9.3 Fix of CmdCheckout errors Fix of CmdRestore fk-dependant tables search algorithm made now iterative Fix of CmdLink now throws exception on failure --- src/main/java/ru/fusionsoft/dbgit/App.java | 187 ++++---- .../fusionsoft/dbgit/command/CmdCheckout.java | 3 +- .../ru/fusionsoft/dbgit/command/CmdLink.java | 9 +- .../fusionsoft/dbgit/command/CmdRestore.java | 32 +- .../fusionsoft/dbgit/command/RequestCmd.java | 132 +++--- .../java/ru/fusionsoft/dbgit/core/DBGit.java | 148 +++--- .../ru/fusionsoft/dbgit/core/DBGitConfig.java | 2 +- .../fusionsoft/dbgit/core/ExceptionDBGit.java | 57 +-- .../dbgit/core/ExceptionDBGitRestore.java | 11 - .../dbgit/core/ExceptionDBGitRunTime.java | 10 - .../dbgit/core/GitMetaDataManager.java | 24 +- .../fusionsoft/dbgit/meta/MetaTableData.java | 7 +- .../dbgit/postgres/DBAdapterPostgres.java | 8 +- .../postgres/DBRestoreTableDataPostgres.java | 26 +- .../fusionsoft/dbgit/utils/ConsoleWriter.java | 9 +- src/main/resources/lang/eng.yaml | 4 +- src/main/resources/lang/rus.yaml | 2 +- .../dbgit/core/DBGitIgnoreTest.java | 7 +- .../integration/ClassCompositionTest.java | 200 -------- .../DbGitIntegrationTestBasic.java | 340 ++++++++++++++ .../DbGitIntegrationTestExtendedCommands.java | 7 + .../DbGitIntegrationTestNotebook.java | 146 ++++++ .../dbgit/integration/DbGitTest.java | 434 ------------------ .../dbgit/integration/SelfTest.java | 196 ++++++++ .../deprecated/PathAfterExecutableRun.java | 10 +- .../primitives/DescribedTestResult.java | 23 +- .../primitives/GroupedTestResult.java | 27 ++ .../integration/primitives/GrouppedTR.java | 34 -- .../primitives/NullPrintStream.java | 14 - ...tchSequental.java => PatchSequential.java} | 6 +- .../integration/primitives/SafeScalarOf.java | 11 +- .../primitives/SimpleTestResult.java | 18 +- .../primitives/args/ArgsCheckoutNodb.java | 12 - .../primitives/args/ArgsRunningCommand.java | 11 +- .../args/specific/ArgsDbGitAdd.java | 13 + .../{ => specific}/ArgsDbGitAddRemote.java | 4 +- .../specific/ArgsDbGitAddRemoteTestRepo.java | 24 + .../args/specific/ArgsDbGitCheckout.java | 16 + .../args/specific/ArgsDbGitClone.java | 18 + .../args/specific/ArgsDbGitInit.java | 9 + .../ArgsDbGitLink.java} | 21 +- .../args/specific/ArgsDbGitLinkPgAuto.java | 7 + ...inkArgs.java => ArgsDbGitLinkPgLocal.java} | 13 +- .../args/specific/ArgsDbGitLinkPgRemote.java | 26 ++ .../args/specific/ArgsDbGitReset.java | 10 + .../args/specific/ArgsDbGitRestore.java | 10 + .../args/specific/AutoPgLinkArgs.java | 10 - .../args/specific/DedicatedPgLinkArgs.java | 27 -- .../specific/GitTestRepoAddRemoteArgs.java | 21 - .../chars/CharsOfConsoleWhenRunning.java | 46 ++ .../chars/CharsOfPathWithComment.java | 11 + .../chars/CharsQuotedToRegexPattern.java | 9 + .../chars/CharsWithMaskedCredentials.java | 31 ++ .../primitives/chars/CommitsFromRepo.java | 10 +- .../primitives/chars/InputStreamChars.java | 41 -- .../chars/LinesFromInputStream.java | 38 ++ .../primitives/chars/SavedConsoleText.java | 69 --- .../chars/TestResultDetailedChars.java | 44 -- .../chars/TestResultShortChars.java | 16 - .../chars/TestSuccessMarkChars.java | 21 - .../NameOfDefaultTargetTestDatabase.java | 9 + .../chars/specific/UrlOfGitTestRepo.java | 9 + .../dbgit/CharsDbIgnoreDefault.java} | 8 +- .../dbgit/CharsDbIgnoreWithTableData.java | 23 + .../dbgit/CharsDbLink.java} | 7 +- .../chars/specific/test/CharsOfLines.java | 21 + .../chars/specific/test/LabelOfTestRun.java | 10 + .../test/LabelOfTestRunBrokenSubject.java | 7 + .../test/LabelOfTestRunExceptional.java | 7 + .../specific/test/LabelOfTestRunResult.java | 7 + .../primitives/chars/specific/test/Lines.java | 7 + .../chars/specific/test/LinesOf.java | 18 + .../chars/specific/test/LinesOfString.java | 17 + .../specific/test/ReportOfTestFormat.java | 33 ++ .../specific/test/ReportOfTestGroupRun.java | 45 ++ .../chars/specific/test/ReportOfTestRun.java | 48 ++ ...dentials.java => CredentialsFromFile.java} | 9 +- ...ls.java => CredentialsFromProperties.java} | 4 +- .../specific/CredsFromGitMvnDProps.java | 9 + ...tials.java => CredsFromGitSecretFile.java} | 6 +- .../specific/CredsFromPgMvnDProps.java | 9 + ...ntials.java => CredsFromPgSecretFile.java} | 6 +- ...edentials.java => CredsOfGitTestRepo.java} | 8 +- ...ntials.java => CredsOfPgTestDatabase.java} | 8 +- .../specific/GitTestRepoPropsCredentials.java | 9 - .../specific/PgPropsCredentials.java | 9 - .../PathPatchAssertsNotMvnProjectRoot.java | 26 ++ .../patch/PathPatchCloningGitRepo.java | 20 +- .../patch/PathPatchConfiguringDbGit.java | 4 +- .../patch/PathPatchCreatingFile.java | 24 +- ...itFrom.java => PathPatchRunningDbGit.java} | 30 +- .../patch/PathPatchRunningExecutable.java | 21 + .../primitives/patch/PathPatchRunningGit.java | 25 + .../patch/PathPatchRunningProcessFrom.java | 62 +-- .../patch/PathPatchWithPrintStream.java | 13 + .../patch/specific/PathPatchDbGitAdd.java | 21 + .../specific/PathPatchDbGitCheckout.java | 18 + .../specific/PathPatchDbGitCheckoutReset.java | 25 + .../specific/PathPatchDbGitClonesRepo.java | 41 ++ .../patch/specific/PathPatchDbGitCommit.java | 16 + .../PathPatchDbGitInitializesRepo.java | 38 ++ .../patch/specific/PathPatchDbGitLink.java | 17 + .../patch/specific/PathPatchDbGitReset.java | 20 + .../patch/specific/PathPatchDbGitRestore.java | 20 + .../specific/PathPatchGitCheckoutOrphan.java | 27 ++ .../path/PathAfterDbGitRestore.java | 42 -- .../primitives/path/PathAfterDbGitRun.java | 9 +- .../primitives/path/PathAfterGitRun.java | 21 + ...mmandRun.java => PathAfterProcessRun.java} | 13 +- .../primitives/path/PathNotProjectRoot.java | 23 +- .../integration/primitives/path/PathOf.java | 2 +- .../primitives/path/PathPatched.java | 5 + .../path/PathWithDbGitCheckoutAndLink.java | 33 -- .../path/PathWithDbGitRepoInitialized.java | 29 -- .../primitives/path/PathWithFiles.java | 17 +- .../primitives/path/PathWithoutFiles.java | 16 +- ...rojectTestResourcesCleanDirectoryPath.java | 2 +- .../dbgit}/PathOfBuiltDbGitExecutable.java | 3 +- .../PathWithDbGitNewRepoInitialized.java | 29 ++ .../dbgit/PathWithDbGitRepoCloned.java | 30 ++ .../PathAfterDbGitCheckoutAndLink.java | 34 ++ .../PathAfterDbGitDumpsDbSchemaToGit.java | 41 ++ .../scenarios/PathAfterDbGitLinkAndAdd.java | 27 ++ ...athWithBuildingDbGitExecutableFromGit.java | 17 +- .../printstream/DefaultPrintStream.java | 9 + .../printstream/OutputStreamToConsole.java | 10 + .../printstream/OutputStreamToNowhere.java | 9 + .../printstream/PrintStreamToConsole.java | 9 + .../printstream/PrintStreamToNowhere.java | 10 + 129 files changed, 2369 insertions(+), 1624 deletions(-) delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/ClassCompositionTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestExtendedCommands.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestNotebook.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/DbGitTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/GroupedTestResult.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/GrouppedTR.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/NullPrintStream.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/{PatchSequental.java => PatchSequential.java} (71%) delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsCheckoutNodb.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAdd.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/{ => specific}/ArgsDbGitAddRemote.java (70%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAddRemoteTestRepo.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitCheckout.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitClone.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitInit.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/{ArgsLink.java => specific/ArgsDbGitLink.java} (68%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgAuto.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/{LocalPgLinkArgs.java => ArgsDbGitLinkPgLocal.java} (52%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgRemote.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitReset.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitRestore.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/DedicatedPgLinkArgs.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/GitTestRepoAddRemoteArgs.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfConsoleWhenRunning.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfPathWithComment.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsQuotedToRegexPattern.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsWithMaskedCredentials.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/InputStreamChars.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/SavedConsoleText.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultDetailedChars.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultShortChars.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestSuccessMarkChars.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/NameOfDefaultTargetTestDatabase.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/UrlOfGitTestRepo.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/{DbIgnoreDefaultChars.java => specific/dbgit/CharsDbIgnoreDefault.java} (63%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreWithTableData.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/{DbLinkChars.java => specific/dbgit/CharsDbLink.java} (64%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/CharsOfLines.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRun.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunBrokenSubject.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunExceptional.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunResult.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/Lines.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOf.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOfString.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestFormat.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestGroupRun.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestRun.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/{FromFileCredentials.java => CredentialsFromFile.java} (57%) rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/{FromPropertiesCredentials.java => CredentialsFromProperties.java} (80%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromGitMvnDProps.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/{GitTestRepoFileCredentials.java => CredsFromGitSecretFile.java} (55%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromPgMvnDProps.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/{PgFileCredentials.java => CredsFromPgSecretFile.java} (56%) rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/{PgCredentials.java => CredsOfGitTestRepo.java} (74%) rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/{GitTestRepoCredentials.java => CredsOfPgTestDatabase.java} (72%) delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoPropsCredentials.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgPropsCredentials.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchAssertsNotMvnProjectRoot.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/{PathPatchRunningDbGitFrom.java => PathPatchRunningDbGit.java} (54%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningExecutable.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningGit.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchWithPrintStream.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitAdd.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckout.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckoutReset.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitClonesRepo.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCommit.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitInitializesRepo.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitLink.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitReset.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitRestore.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchGitCheckoutOrphan.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRestore.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterGitRun.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/{PathAfterCommandRun.java => PathAfterProcessRun.java} (53%) delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitCheckoutAndLink.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitRepoInitialized.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/{ => specific/dbgit}/PathOfBuiltDbGitExecutable.java (65%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathWithDbGitNewRepoInitialized.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathWithDbGitRepoCloned.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitCheckoutAndLink.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitDumpsDbSchemaToGit.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitLinkAndAdd.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/{ => specific/dbgit/scenarios}/PathWithBuildingDbGitExecutableFromGit.java (73%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/DefaultPrintStream.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/OutputStreamToConsole.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/OutputStreamToNowhere.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/PrintStreamToConsole.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/PrintStreamToNowhere.java diff --git a/src/main/java/ru/fusionsoft/dbgit/App.java b/src/main/java/ru/fusionsoft/dbgit/App.java index cc9f96a..38bc237 100644 --- a/src/main/java/ru/fusionsoft/dbgit/App.java +++ b/src/main/java/ru/fusionsoft/dbgit/App.java @@ -1,112 +1,129 @@ package ru.fusionsoft.dbgit; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.net.URL; + +import java.sql.Connection; +import java.sql.SQLException; +import java.text.MessageFormat; import org.apache.commons.cli.CommandLine; -import org.slf4j.LoggerFactory; +import org.junit.platform.commons.util.ExceptionUtils; + -import ch.qos.logback.classic.LoggerContext; -import ch.qos.logback.classic.joran.JoranConfigurator; -import ch.qos.logback.classic.util.ContextInitializer; -import ch.qos.logback.core.joran.spi.JoranException; -import ch.qos.logback.core.util.StatusPrinter; import ru.fusionsoft.dbgit.command.RequestCmd; +import ru.fusionsoft.dbgit.core.DBConnection; import ru.fusionsoft.dbgit.core.DBGitLang; import ru.fusionsoft.dbgit.core.DBGitPath; import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.utils.ConsoleWriter; import ru.fusionsoft.dbgit.utils.LoggerUtil; +public class App { + + public static void main( String[] args ) { + //configureLogback(); + + try { + DBGitPath.createLogDir(); + DBGitPath.deleteOldLogs(); + executeDbGitCommand(args); + } catch (Error | Exception e) { + final String msg = DBGitLang.getInstance() + .getValue("errors", "executionError") + .toString(); + + LoggerUtil.getGlobalLogger().error(msg, e); + System.err.println(MessageFormat.format( + "{0}:\n{1}", + msg, + ExceptionUtils.readStackTrace(e) + )); + + rollbackConnection(); + System.exit(1); + } finally { + DBGitPath.clearTempDir(); + } + + } -/** - * Hello world! - * - */ -public class App -{ public static void executeDbGitCommand(String[] args) throws Exception { RequestCmd cmd = RequestCmd.getInstance(); - CommandLine cmdLine = cmd.parseCommand(args); - if (cmdLine.hasOption('h')) { cmd.printHelpAboutCommand(cmd.getCommand()); - return ; + return; } - cmd.getCurrentCommand().execute(cmdLine); } - - private static void configureLogback() throws JoranException, IOException { - LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); - JoranConfigurator jc = new JoranConfigurator(); - jc.setContext(context); - context.reset(); - - // overriding the log directory property programmatically - String logDirProperty = ".";// ... get alternative log directory location - - context.putProperty("LOG_DIR", logDirProperty); - //System.out.rintln(CProperties.getProperty("log_root_level")); - context.putProperty("log_root_level", "debug"); - - - ClassLoader classLoader = App.class.getClassLoader(); - File file = new File(classLoader.getResource("logback.xml").getFile()); - FileInputStream fis = new FileInputStream(file); - jc.doConfigure(fis); - - - /* - // this assumes that the logback.xml file is in the root of the bundle. - URL logbackConfigFileUrl = new URL("logback.xml"); - jc.doConfigure(logbackConfigFileUrl.openStream()); - */ + + private static void rollbackConnection() { + if (DBConnection.hasInstance()) try { + DBConnection dbConnection = DBConnection.getInstance(); + Connection connection = dbConnection.getConnect(); + if (connection != null && ! connection.isClosed()) { + connection.rollback(); + connection.close(); + } + } catch (Exception ex) { + if (ex instanceof ExceptionDBGit || ex instanceof SQLException) { + ConsoleWriter.println(DBGitLang.getInstance() + .getValue("errors", "onExceptionTransactionRollbackError") + .withParams(ex.getLocalizedMessage()) + , 0 + ); + } else { + ConsoleWriter.printlnRed( + ex.getLocalizedMessage(), + 0 + ); + } + } } - - private static void updateLogback() { - LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); - - ContextInitializer ci = new ContextInitializer(loggerContext); - URL url = ci.findURLOfDefaultConfigurationFile(true); - try { - JoranConfigurator configurator = new JoranConfigurator(); - configurator.setContext(loggerContext); - loggerContext.reset(); - configurator.doConfigure(url); - } catch (JoranException je) { - // StatusPrinter will handle this - } - StatusPrinter.printInCaseOfErrorsOrWarnings(loggerContext); - } - - public static void main( String[] args ) throws Exception - { - //configureLogback(); - - try { - DBGitPath.createLogDir(); - DBGitPath.deleteOldLogs(); - - executeDbGitCommand(args); - - } catch (Exception e) { - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("errors", "executionError") - .withParams(e.getMessage()) - , 0 - ); - LoggerUtil.getGlobalLogger().error(e.getMessage(), e); - } finally { - DBGitPath.clearTempDir(); - } - - } +// private static void configureLogback() throws JoranException, IOException { +// LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); +// JoranConfigurator jc = new JoranConfigurator(); +// jc.setContext(context); +// context.reset(); +// +// // overriding the log directory property programmatically +// String logDirProperty = ".";// ... get alternative log directory location +// +// context.putProperty("LOG_DIR", logDirProperty); +// //System.out.rintln(CProperties.getProperty("log_root_level")); +// context.putProperty("log_root_level", "debug"); +// +// +// ClassLoader classLoader = App.class.getClassLoader(); +// File file = new File(classLoader.getResource("logback.xml").getFile()); +// FileInputStream fis = new FileInputStream(file); +// jc.doConfigure(fis); +// +// +// /* +// // this assumes that the logback.xml file is in the root of the bundle. +// URL logbackConfigFileUrl = new URL("logback.xml"); +// jc.doConfigure(logbackConfigFileUrl.openStream()); +// */ +// } +// +// private static void updateLogback() { +// LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); +// +// ContextInitializer ci = new ContextInitializer(loggerContext); +// URL url = ci.findURLOfDefaultConfigurationFile(true); +// +// try { +// JoranConfigurator configurator = new JoranConfigurator(); +// configurator.setContext(loggerContext); +// loggerContext.reset(); +// configurator.doConfigure(url); +// } catch (JoranException je) { +// // StatusPrinter will handle this +// } +// StatusPrinter.printInCaseOfErrorsOrWarnings(loggerContext); +// } } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java index 32f3245..5acda93 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdCheckout.java @@ -58,6 +58,7 @@ public void execute(CommandLine cmdLine) throws Exception { if (cmdLine.hasOption("ls")){ try(RevWalk walk = new RevWalk(repo)){ + String branch = repo.getBranch(); String headNumber = head.getObjectId().getName(); String headName = head.getName(); @@ -66,7 +67,7 @@ public void execute(CommandLine cmdLine) throws Exception { System.out.println(DBGitLang.getInstance() .getValue("general", "checkout", "printBranchAndCommit") .withParams( - !branch.equals(headNumber) ? branch + ": " + headName : headNumber, + !branch.equals(headNumber) ? branch + ": " + headNumber : headNumber, headName, message ) diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java index 272ccda..f4f343a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdLink.java @@ -60,10 +60,11 @@ public void execute(CommandLine cmdLine) throws Exception { String url = args[0]; Properties props = CreateProperties(Arrays.copyOfRange(args, 1, args.length)); - if(conn.testingConnection(url, props)) { - DBConnection.createFileDBLink(url, props, cmdLine.hasOption("d")); - DBGitPath.createDefaultDbignore(DBGitPath.getFullPath(), url, props); - } + DBConnection.createFileDBLink(url, props, cmdLine.hasOption("d")); + DBGitPath.createDefaultDbignore(DBGitPath.getFullPath(), url, props); + if(!conn.testingConnection(url, props)) { + throw new ExceptionDBGit("Db connection link seems not working"); + } } public Properties CreateProperties(String[] args) { diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java index 6ac8a42..513578e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java @@ -73,9 +73,10 @@ public void execute(CommandLine cmdLine) throws Exception { IMapMetaObject updateObjs = new TreeMapMetaObject(); IMapMetaObject deleteObjs = new TreeMapMetaObject(); - if (toMakeBackup) { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "willMakeBackup").toString(), Ansi.FColor.GREEN, 1); } - if (toMakeChanges) { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "toMakeChanges").toString(), Ansi.FColor.GREEN, 1); } - else { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "notMakeChanges").withParams(autoScriptFile.getAbsolutePath()), Ansi.FColor.GREEN, 1); } + if (toMakeBackup) { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "willMakeBackup").toString(), Ansi.FColor.GREEN, messageLevel+1); } + else { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "wontMakeBackup").toString(), Ansi.FColor.GREEN, messageLevel+1); } + if (toMakeChanges) { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "toMakeChanges").toString(), Ansi.FColor.GREEN, messageLevel+1); } + else { ConsoleWriter.printlnColor(getLang().getValue("general", "restore", "notMakeChanges").withParams(autoScriptFile.getAbsolutePath()), Ansi.FColor.GREEN, messageLevel+1); } //delete that not present in HEAD try { @@ -140,19 +141,25 @@ public void execute(CommandLine cmdLine) throws Exception { // # steps 1,2 are in GitMetaDataManager::restoreDatabase ConsoleWriter.println(getLang().getValue("general", "restore", "seekingToRestoreAdditional"),1); - Map affectedTables = dbObjs.values().stream().filter(excluded -> - excluded instanceof MetaTable && - !updateObjs.containsKey(excluded.getName()) && - updateObjs.values().stream().anyMatch( included -> excluded.dependsOn(included) ) - ).collect(Collectors.toMap( key -> key.getName(), val -> val)); - - + Map affectedTables = new TreeMapMetaObject(); + Map foundTables = new TreeMapMetaObject(); + do { + foundTables = + dbObjs.values().stream() + .filter(excluded -> { + return excluded instanceof MetaTable + && ! updateObjs.containsKey(excluded.getName()) + && updateObjs.values().stream().anyMatch(excluded::dependsOn); + }) + .collect(Collectors.toMap(IMetaObject::getName, val -> val)); + affectedTables.putAll(foundTables); + updateObjs.putAll(foundTables); + } while (!foundTables.isEmpty()); + if(affectedTables.isEmpty()){ ConsoleWriter.println(getLang().getValue("general", "restore", "nothingToRestoreAdditional"), 2); } else { -// ConsoleWriter.print(getLang().getValue("general", "restore", "toRestoreAdditional")); affectedTables.forEach((k,v)->ConsoleWriter.println(k, 2)); - updateObjs.putAll( affectedTables ); } @@ -212,6 +219,7 @@ private File createScriptFile() throws ExceptionDBGit, IOException { DBGitPath.createScriptsDir(); SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); File scriptFile = new File(DBGitPath.getScriptsPath() + "script-" + format.format(new Date()) + ".sql"); +// System.out.println(scriptFile.getAbsolutePath()); if (!scriptFile.exists()) { scriptFile.createNewFile(); } return scriptFile; } diff --git a/src/main/java/ru/fusionsoft/dbgit/command/RequestCmd.java b/src/main/java/ru/fusionsoft/dbgit/command/RequestCmd.java index 9c876a4..d693219 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/RequestCmd.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/RequestCmd.java @@ -96,11 +96,9 @@ protected static Options addHelpOptions(Options opts) throws ExceptionDBGit { if (opts.getOption("h") == null) { opts.addOption("h", false, DBGitLang.getInstance().getValue("help", "h").toString()); } - if (opts.getOption("v") == null) { opts.addOption("v", false, DBGitLang.getInstance().getValue("help", "v").toString()); } - return opts; } @@ -108,11 +106,8 @@ public void printHelpAboutCommand(String command) throws Exception { if (!commands.containsKey(command)) { throw new ExceptionCmdNotFound(DBGitLang.getInstance().getValue("errors", "commandNotFound").withParams(command)); } - IDBGitCommand cmdObj = commands.get(command); - HelpFormatter helpFormatter = new HelpFormatter(); - helpFormatter.printHelp( "dbgit "+command+" "+cmdObj.getParams(), cmdObj.getHelperInfo(), @@ -123,69 +118,66 @@ public void printHelpAboutCommand(String command) throws Exception { } - public static void main( String[] args ) throws Exception - { - ConsoleWriter.println( "dbgit utils - Hello!", 0); - - //configureLogback(); - - try { - CommandLineParser clParse = new DefaultParser(); - Options opts = new Options(); - opts.addOption("a", false, "Option A"); - opts.addOption("b", true, "Option B"); - opts.addOption("c", false, "Option C"); - opts.addOption("f", false, "Flag F"); - - addHelpOptions(opts); - - CommandLine cmdLine = clParse.parse(opts, args); - System.out.println(cmdLine.getArgs().length); - - System.out.println(cmdLine.hasOption('a')); - System.out.println(cmdLine.hasOption('c')); - - - HelpFormatter helpFormatter = new HelpFormatter(); - //helpFormatter.setArgName("argument"); - helpFormatter.printHelp("this help", "header", opts, "footer", true); - - - /* - printHelp( - opts, // опции по которым составляем help - 80, // ширина строки вывода - "Options", // строка предшествующая выводу - "-- HELP --", // строка следующая за выводом - 3, // число пробелов перед выводом опции - 5, // число пробелов перед выводом опцисания опции - true, // выводить ли в строке usage список команд - System.out // куда производить вывод - ); - - */ - - for (int i = 0; i < cmdLine.getArgs().length; i++) { - System.out.println(cmdLine.getArgs()[i]); - } - - - - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("general", "commandSuccess") - , 0 - ); - } catch (Exception e) { - ConsoleWriter.printlnRed(DBGitLang.getInstance() - .getValue("errors", "cmdException") - .withParams(e.getMessage()) - , 0 - ); - LoggerUtil.getGlobalLogger().error(e.getMessage(), e); - } - - } - - - +// public static void main( String[] args ) throws Exception +// { +// ConsoleWriter.println( "dbgit utils - Hello!", 0); +// +// //configureLogback(); +// +// try { +// CommandLineParser clParse = new DefaultParser(); +// Options opts = new Options(); +// opts.addOption("a", false, "Option A"); +// opts.addOption("b", true, "Option B"); +// opts.addOption("c", false, "Option C"); +// opts.addOption("f", false, "Flag F"); +// +// addHelpOptions(opts); +// +// CommandLine cmdLine = clParse.parse(opts, args); +// System.out.println(cmdLine.getArgs().length); +// +// System.out.println(cmdLine.hasOption('a')); +// System.out.println(cmdLine.hasOption('c')); +// +// +// HelpFormatter helpFormatter = new HelpFormatter(); +// //helpFormatter.setArgName("argument"); +// helpFormatter.printHelp("this help", "header", opts, "footer", true); +// +// +// /* +// printHelp( +// opts, // опции по которым составляем help +// 80, // ширина строки вывода +// "Options", // строка предшествующая выводу +// "-- HELP --", // строка следующая за выводом +// 3, // число пробелов перед выводом опции +// 5, // число пробелов перед выводом опцисания опции +// true, // выводить ли в строке usage список команд +// System.out // куда производить вывод +// ); +// +// */ +// +// for (int i = 0; i < cmdLine.getArgs().length; i++) { +// System.out.println(cmdLine.getArgs()[i]); +// } +// +// +// +// ConsoleWriter.println(DBGitLang.getInstance() +// .getValue("general", "commandSuccess") +// , 0 +// ); +// } catch (Exception e) { +// ConsoleWriter.printlnRed(DBGitLang.getInstance() +// .getValue("errors", "cmdException") +// .withParams(e.getMessage()) +// , 0 +// ); +// LoggerUtil.getGlobalLogger().error(e.getMessage(), e); +// } +// +// } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java index 0c70fbf..16076de 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGit.java @@ -11,6 +11,7 @@ import org.eclipse.jgit.api.*; import org.eclipse.jgit.api.ListBranchCommand.ListMode; import org.eclipse.jgit.api.ResetCommand.ResetType; +import org.eclipse.jgit.api.errors.GitAPIException; import org.eclipse.jgit.dircache.DirCache; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Ref; @@ -259,66 +260,109 @@ public void gitCommit(boolean existsSwitchA, String msg, String path) throws Exc } } - public void gitCheckout(String branch, String commit, boolean isNewBranch) throws ExceptionDBGit { - try { - ConsoleWriter.detailsPrintln(DBGitLang.getInstance().getValue("general", "checkout", "do"), messageLevel); - ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "checkout", "toCreateBranch") - .withParams(String.valueOf(isNewBranch)) - , messageLevel+1 + public void printCurrentCommit() throws IOException { + try (RevWalk walk = new RevWalk(repository)) { + ConsoleWriter.detailsPrintlnGreen( + DBGitLang.getInstance().getValue("general", "checkout", "commitMessage") + .withParams(walk.parseCommit(repository.getAllRefs().get("HEAD").getObjectId()).getShortMessage()) + , messageLevel + 1 ); - ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "checkout", "branchName") - .withParams(branch) - , messageLevel+1 + } + } + + public boolean nameInLocalRepoExistence(String name) throws IOException { + return git.getRepository().findRef(name) != null; + } + + public boolean nameInRemoteRepoExistence(String name) throws GitAPIException { + return git.branchList().setListMode(ListMode.REMOTE).call().stream() + .anyMatch(ref -> ref.getName().equals("refs/remotes/origin/" + name)); + } + + public void gitCheckoutName(String name) throws Exception { + final CheckoutCommand checkoutCommand = git.checkout().setName(name); + + if (nameInLocalRepoExistence(name)) { + ConsoleWriter.detailsPrintlnGreen( + DBGitLang.getInstance().getValue("general", "checkout", "branchName").withParams(name), messageLevel + 1 ); - if (commit != null){ - ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "checkout", "commitName") - .withParams(commit) - , messageLevel+1 - ); + if(nameInRemoteRepoExistence(name)) { + checkoutCommand.setStartPoint("origin/" + name); } + } else { + ConsoleWriter.detailsPrintlnGreen( + DBGitLang.getInstance().getValue("general", "checkout", "commitName").withParams(name), messageLevel + 1 + ); + } - Ref result; - if (git.getRepository().findRef(branch) != null || isNewBranch) { - - CheckoutCommand checkout = git.checkout().setCreateBranch(isNewBranch).setName(branch); - - if (commit != null){ - checkout = checkout.setName(commit); - } else { - if (git.branchList().setListMode(ListMode.REMOTE).call().stream() - .filter(ref -> ref.getName().equals("refs/remotes/origin/" + branch)) - .count() > 0 - )checkout = checkout.setStartPoint("remotes/origin/" + branch); - } - - result = checkout.call(); - - try(RevWalk walk = new RevWalk(repository)){ - ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "checkout", "commitMessage") - .withParams(walk.parseCommit(repository.getAllRefs().get("HEAD").getObjectId()).getShortMessage()) - , messageLevel+1 - ); - } - - + checkoutCommand.call(); + printCurrentCommit(); + } + + public void gitCheckoutNewBranch(String branchName, String commitHash) throws Exception { + final CheckoutCommand checkoutCommand = git.checkout(); + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "checkout", "branchName").withParams(branchName), messageLevel + 1); + if(commitHash != null) { + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "checkout", "commitName").withParams(commitHash), messageLevel + 1); + } + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "checkout", "toCreateBranch").withParams(String.valueOf(true)), messageLevel + 1); + + checkoutCommand.setCreateBranch(true); + checkoutCommand.setName(branchName); + if(commitHash != null) { + if(nameInLocalRepoExistence(commitHash)) { + checkoutCommand.setStartPoint(commitHash); } else { - MaskFilter maskAdd = new MaskFilter(branch); - - int counter = 0; - for (String path: getGitIndexFiles(DBGitPath.DB_GIT_PATH)) { - if (maskAdd.match(path)) { - result = git.checkout().setName(git.getRepository().getBranch()).addPath(DBGitPath.DB_GIT_PATH + "/" + path).call(); - counter++; - } - } - String s = ""; - if (counter != 1) s = "s"; - ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "checkout", "updatedFromIndex").withParams(String.valueOf(counter), s), 1); + throw new ExceptionDBGit("Can not find the local commit specified: " + commitHash); + } + } else if (nameInRemoteRepoExistence(branchName)){ + checkoutCommand.setStartPoint("origin/" + branchName); + } + //else { + // you would checkout HEAD - create new branch from current one's HEAD + // https://stackoverflow.com/a/37131407 + //} + checkoutCommand.call(); + } + + public void gitCheckoutFileName(String fileName) throws Exception{ + MaskFilter maskAdd = new MaskFilter(fileName); + ConsoleWriter.println("Checking out files...", messageLevel+1); + + int counter = 0; + for (String path : getGitIndexFiles(DBGitPath.DB_GIT_PATH)) { + if (maskAdd.match(path)) { + git.checkout() + .setName(git.getRepository() + .getBranch()) + .addPath(DBGitPath.DB_GIT_PATH + "/"+ path) + .call(); + counter++; + } + } + String messageTailChars = counter != 1 ? "s" : ""; + ConsoleWriter.println( + DBGitLang.getInstance().getValue("general", "checkout", "updatedFromIndex") + .withParams(String.valueOf(counter), messageTailChars) + , messageLevel+1 + ); + } + + public void gitCheckout(String arg1, String arg2, boolean isNewBranch) throws ExceptionDBGit { + try { + ConsoleWriter.println(DBGitLang.getInstance().getValue("general", "checkout", "do"), messageLevel); + if(isNewBranch) { + gitCheckoutNewBranch(arg1, arg2); + } else { +// if(nameInRemoteRepoExistence(arg1) || nameInLocalRepoExistence(arg1)) { + gitCheckoutName(arg1); +// } else { +// gitCheckoutFileName(arg1); +// } } - } catch (Exception e) { - throw new ExceptionDBGit(e); + throw new ExceptionDBGit("Failed to do checkout", e); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java index d3b79bc..d81c84c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitConfig.java @@ -136,7 +136,7 @@ public void setValueGlobal(String parameter, String value) throws ExceptionDBGit public void setValue(String parameter, String value, boolean global) throws ExceptionDBGit { try { if (global) { - if (!iniGlobal.get("core").containsKey(parameter) && !parameter.equals("CURRENT_OBJECT")) + if (!iniGlobal.get("core").containsKey(parameter) /*&& !parameter.equals("CURRENT_OBJECT")*/) ConsoleWriter.detailsPrintln( DBGitLang.getInstance().getValue("errors", "config", "noParameter").withParams(parameter) , messageLevel diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java index 087d1a1..8cb9527 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGit.java @@ -18,68 +18,17 @@ public class ExceptionDBGit extends Exception { private static final long serialVersionUID = -4613368557825624023L; - protected static final int messageLevel = 0; - protected final Logger logger = LoggerUtil.getLogger(this.getClass()); - private final Throwable cause; - private final String contextMessage; public ExceptionDBGit(Object msg) { - this.contextMessage = msg.toString(); - this.cause = null; - handleException(); + super(String.valueOf(msg)); } public ExceptionDBGit(Object message, Throwable cause) { - this.contextMessage = message.toString(); - this.cause = cause; - handleException(); + super(String.valueOf(message), cause); } public ExceptionDBGit(Throwable cause) { - this.cause = cause; - this.contextMessage = ""; - handleException(); + super(cause); } - private void handleException(){ - printMessageAndStackTrace(); - rollbackConnection(); - System.exit(1); - } - protected void printMessageAndStackTrace(){ - if(!contextMessage.isEmpty() && (cause == null || !cause.getMessage().equals(contextMessage))) { - ConsoleWriter.printlnRed(contextMessage, messageLevel); - ConsoleWriter.printLineBreak(); - } - - if(cause != null){ - ConsoleWriter.printlnRed(cause.getLocalizedMessage(), messageLevel); - ConsoleWriter.printLineBreak(); - ConsoleWriter.detailsPrintlnRed(ExceptionUtils.getStackTrace(cause), messageLevel); - logger.error(!contextMessage.isEmpty() ? contextMessage : cause.getMessage(), cause); - } else { - ConsoleWriter.detailsPrintlnRed(ExceptionUtils.getStackTrace(this), messageLevel); - logger.error(!contextMessage.isEmpty() ? contextMessage : "no error message provided..." , this); - } - } - private void rollbackConnection() { - if(DBConnection.hasInstance()) try{ - DBConnection dbConnection = DBConnection.getInstance(); - Connection connection = dbConnection.getConnect(); - if(connection != null && !connection.isClosed()){ - connection.rollback(); - connection.close(); - } - } catch (Exception ex) { - if(ex instanceof ExceptionDBGit || ex instanceof SQLException) { - ConsoleWriter.println(DBGitLang.getInstance() - .getValue("errors", "onExceptionTransactionRollbackError") - .withParams(ex.getLocalizedMessage()) - , 0 - ); - } else { - ConsoleWriter.printlnRed(ex.getLocalizedMessage(), messageLevel); - } - } - } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java index 439d04c..3ade4de 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRestore.java @@ -1,7 +1,5 @@ package ru.fusionsoft.dbgit.core; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - public class ExceptionDBGitRestore extends ExceptionDBGit { private static final long serialVersionUID = -8714585942496838509L; @@ -10,14 +8,5 @@ public class ExceptionDBGitRestore extends ExceptionDBGit { public ExceptionDBGitRestore(Object message, Throwable cause) { super(message, cause); } public ExceptionDBGitRestore(Throwable cause) { super(cause); } - @Override public void printMessageAndStackTrace(){ - printFail(); - super.printMessageAndStackTrace(); - } - private void printFail(){ - ConsoleWriter.detailsPrintRed(DBGitLang.getInstance() - .getValue("errors", "meta", "fail") - ); - } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java index 04ff5e2..10dda5e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/ExceptionDBGitRunTime.java @@ -1,29 +1,19 @@ package ru.fusionsoft.dbgit.core; -import org.apache.commons.lang3.exception.ExceptionUtils; -import org.slf4j.Logger; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; -import ru.fusionsoft.dbgit.utils.LoggerUtil; - -import java.sql.SQLException; public class ExceptionDBGitRunTime extends RuntimeException { private static final long serialVersionUID = 958722213419205629L; - private ExceptionDBGit exceptionDBGit; public ExceptionDBGitRunTime(Object msg) { super(msg.toString()); - exceptionDBGit = new ExceptionDBGit(this); } public ExceptionDBGitRunTime(Object message, Throwable cause) { super(message.toString(), cause); - exceptionDBGit = new ExceptionDBGit(message, this); } public ExceptionDBGitRunTime(Throwable cause) { super(cause); - exceptionDBGit = new ExceptionDBGit(this); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java index 8608625..a95d943 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java @@ -323,22 +323,22 @@ public IMapMetaObject loadFileMetaData(boolean force) throws ExceptionDBGit { objs.put(obj); } } catch (Exception e) { - isSuccessful = false; - ConsoleWriter.printlnRed(DBGitLang.getInstance().getValue("errors", "meta", "loadMetaFile") - .withParams(filename) - , messageLevel - ); - ConsoleWriter.detailsPrintln(e.getMessage(), messageLevel); - - IMetaObject obj = MetaObjectFactory.createMetaObject(filename); - objs.put(obj); +// ConsoleWriter.printlnRed(DBGitLang.getInstance().getValue("errors", "meta", "loadMetaFile") + final String msg = DBGitLang.getInstance() + .getValue("errors", "meta", "cantLoadMetaFile") + .withParams(filename); + throw new ExceptionDBGit(msg, e); +// isSuccessful = false; +// ConsoleWriter.detailsPrintln(e.getMessage(), messageLevel); +// IMetaObject obj = MetaObjectFactory.createMetaObject(filename); +// objs.put(obj); } } } - if (!isSuccessful && !force) { - throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "meta", "invalidFiles")); - } +// if (!isSuccessful && !force) { +// throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "meta", "invalidFiles")); +// } return objs; } catch(Exception e) { diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index aa44bca..bc8d8cf 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -173,6 +173,7 @@ public IMetaObject deSerialize(File file) throws Exception { CsvReader csvReader = new CsvReader(); csvReader.setFieldSeparator(';'); + csvReader.setContainsHeader(false); int i = 1; try (CsvParser csvParser = csvReader.parse(file, StandardCharsets.UTF_8)) { @@ -186,6 +187,7 @@ public IMetaObject deSerialize(File file) throws Exception { if (!flag) { titleColumns = row; fields = row.getFields(); +// System.err.println("fields = " + fields); } else { RowData rd = new RowData(row, metaTable, titleColumns); mapRows.put(rd); @@ -194,11 +196,11 @@ public IMetaObject deSerialize(File file) throws Exception { flag = true; } } catch (Throwable ex){ - ConsoleWriter.detailsPrintlnRed(DBGitLang.getInstance().getValue("general", "meta", "loadRow").withParams(String.valueOf(i) ), messageLevel); + ConsoleWriter.detailsPrint(DBGitLang.getInstance().getValue("general", "meta", "loadRow").withParams(String.valueOf(i) )); warnFilesNotFound(); throw ex; } - ConsoleWriter.detailsPrintlnGreen(DBGitLang.getInstance().getValue("general", "meta", "loadedRow").withParams(String.valueOf(i) ), messageLevel); + ConsoleWriter.detailsPrint(DBGitLang.getInstance().getValue("general", "meta", "loadedRow").withParams(String.valueOf(i) )); warnFilesNotFound(); return this; @@ -206,6 +208,7 @@ public IMetaObject deSerialize(File file) throws Exception { @Override + @Deprecated public IMetaObject deSerialize(InputStream stream) throws Exception { MetaTable metaTable = getMetaTableFromFile(); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index 7200261..21d5e12 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -188,7 +188,9 @@ public Map getTables(String schema) { " tablename AS table_name,\n" + " tableowner AS owner,\n" + " tablespace, hasindexes, hasrules, hastriggers, \n" + - " obj_description( (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment,\n" + + " obj_description( " + + " (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid" + + " ) AS table_comment,\n" + " (\n" + " SELECT array_agg( distinct n2.nspname || '/' || c2.relname || '.tbl' ) AS dependencies\n" + " FROM pg_catalog.pg_constraint c \n" + @@ -253,7 +255,7 @@ public DBTable getTable(String schema, String name) { " tablename AS table_name,\n" + " tableowner AS owner,\n" + " tablespace, hasindexes, hasrules, hastriggers, \n" + - " obj_description( (('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment,\n" + + " obj_description((('\"' || schemaname || '\".\"' || tablename || '\"')::regclass)::oid) AS table_comment,\n" + " (\n" + " SELECT array_agg( distinct n2.nspname || '/' || c2.relname || '.tbl' ) AS dependencies\n" + " FROM pg_catalog.pg_constraint c \n" + @@ -775,7 +777,7 @@ public Map getFunctions(String schema) { " LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n" + ( (getDbVersionNumber() >= 10) ? "WHERE p.prokind = 'f' \n" - : "WHERE 1=1 " + : "WHERE p.proisagg is false " )+ "AND n.nspname not in('pg_catalog', 'information_schema')\n" + "AND n.nspname = '"+schema+"'"; diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index 1bafb11..fd88d67 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -128,6 +128,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ List fieldsList = restoreTableData.getFields(); +// System.err.println("fieldsList = " + String.join(",", fieldsList)); if(fieldsList.size() == 0 ) { ConsoleWriter.printlnRed(DBGitLang.getInstance() .getValue("errors", "restore", "emptyFieldsList") @@ -160,7 +161,8 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa .map(DBTableField::getName) .collect(Collectors.toSet()); - + System.out.println("\ndiffTableData.entriesOnlyOnRight().isEmpty() = " + + diffTableData.entriesOnlyOnRight().isEmpty()); //DELETE if (!diffTableData.entriesOnlyOnRight().isEmpty()) { ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); @@ -180,23 +182,28 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa String delFields = "(" + fieldJoiner.toString() + ")"; String delValues = "(" + valuejoiner.toString() + ")"; - if (delValues.length() > 3){ + if (delValues.length() > 2){ deleteQuery.append("DELETE FROM ").append(tblNameEscaped) .append(" WHERE ").append(delFields).append(" = ") .append(delValues).append(";\n"); } if (deleteQuery.length() > 50000) { + ConsoleWriter.detailsPrintln(deleteQuery, messageLevel + 1); st.execute(deleteQuery.toString()); deleteQuery = new StringBuilder(); } } if (deleteQuery.length() > 1) { + ConsoleWriter.detailsPrintln(deleteQuery, messageLevel + 1); st.execute(deleteQuery.toString()); } ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); } + System.out.println("\nentriesDiffering().isEmpty() = " + + diffTableData.entriesDiffering().isEmpty()); //UPDATE + ConsoleWriter.detailsPrintln("Entries differing count: " + diffTableData.entriesDiffering().keySet().size(), messageLevel); if (!diffTableData.entriesDiffering().isEmpty()) { ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "updating"), messageLevel); String updateQuery = ""; @@ -256,15 +263,15 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "inserting"), messageLevel); for (RowData rowData : diffTableData.entriesOnlyOnLeft().values()) { - String insertQuery = MessageFormat.format("INSERT INTO {0}{1}{2};\n" - , tblNameEscaped, fields - , valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) + String insertQuery = MessageFormat.format("INSERT INTO {0}{1}{2};" + , tblNameEscaped, fields + , valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) ); - ConsoleWriter.detailsPrintln(insertQuery, messageLevel); + ConsoleWriter.detailsPrintln(insertQuery, messageLevel+1); st.execute(insertQuery); } - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + ConsoleWriter.detailsPrintln(lang.getValue("general", "ok"), messageLevel); } } catch (Exception e) { @@ -440,7 +447,7 @@ public void removeTableConstraintsPostgres(MetaTable table) throws Exception { StatementLogging stCnt = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql()); String schema = getPhisicalSchema(table.getTable().getSchema()); schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); - String tblName = schema + "." +table.getTable().getName(); + String tblName = adapter.escapeNameIfNeeded(schema) + "." + adapter.escapeNameIfNeeded(table.getTable().getName()); ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "delConstr").withParams(table.getName()), messageLevel); try { ResultSet rs = stCnt.executeQuery("SELECT *\r\n" + @@ -465,7 +472,8 @@ public void removeTableConstraintsPostgres(MetaTable table) throws Exception { while (rs.next()) { if(!rs.getString("contype").equals("p")) { - st.execute("alter table "+schema+"."+ table.getTable().getName() +" drop constraint if exists "+rs.getString("conname")); + st.execute( + "alter table "+ tblName +" drop constraint if exists "+adapter.escapeNameIfNeeded(rs.getString("conname"))); } } //} diff --git a/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java b/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java index 798b647..a310377 100644 --- a/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java +++ b/src/main/java/ru/fusionsoft/dbgit/utils/ConsoleWriter.java @@ -20,14 +20,13 @@ public static void print(Object message, FColor color, int level, boolean newLin if(onlyDetailed && !showDetailedLog) return; String tab = StringUtils.leftPad("", 4*level, " "); - String msg = MessageFormat.format("{0}{1}{2}", - newLine ? "\n" : "", + String msg = MessageFormat.format("{0}{1}", tab, message.toString() ); - - cp.print(msg, Attribute.NONE, color, BColor.BLACK); - cp.clear(); + System.out.print(( newLine ? "\n" : " " ) + msg ); +// cp.print(msg, Attribute.NONE, color, BColor.BLACK); +// cp.clear(); } diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index a03d9c5..d7e0f72 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -98,6 +98,7 @@ general: updating: Updating... unsupportedTypes: Table {0} contains unsupported types, it will be skipped willMakeBackup: Backup option enabled, all objects will be backed up before making changes + wontMakeBackup: Backup option DISABLED, no objects will be backed up before making changes toMakeChanges: Restore key specified, the operation will make changes to database notMakeChanges: The operation will NOT make changes to database rm: @@ -165,7 +166,7 @@ errors: cmdException: "Error execute dbgit: {0}" onExceptionTransactionRollbackError: "Failed to rollback connection: {0}" commandNotFound: Command {0} not found! - executionError: Error execute dbgit {0} + executionError: Error execute dbgit gitRepNotFound: Git repository not found gitLoginNotFound: Can't find git login gitPasswordNotFound: Can't find git password @@ -236,6 +237,7 @@ errors: tooManyRecords: Table {0} has more than {1} records. dbgit can't save this table data. compareMetaError: compareMeta Error! {0} to {1} loadMetaFile: Could not load meta file {0}, using dummy version instead! + cantLoadMetaFile: Could not load meta file {0} dataTable: errorCellData: Error create CellData for type {0} differentCount: Different count columns title and line diff --git a/src/main/resources/lang/rus.yaml b/src/main/resources/lang/rus.yaml index 02191c1..f675906 100644 --- a/src/main/resources/lang/rus.yaml +++ b/src/main/resources/lang/rus.yaml @@ -79,4 +79,4 @@ help: -h Показывает эту помощь -v Выводит полный отчет выполнения команды - \ No newline at end of file + diff --git a/src/test/java/ru/fusionsoft/dbgit/core/DBGitIgnoreTest.java b/src/test/java/ru/fusionsoft/dbgit/core/DBGitIgnoreTest.java index b75d80e..f842ad2 100644 --- a/src/test/java/ru/fusionsoft/dbgit/core/DBGitIgnoreTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/core/DBGitIgnoreTest.java @@ -12,11 +12,9 @@ public class DBGitIgnoreTest { DBGitIgnore dbGitIgnore; Map filters = new HashMap<>(); Map exclusions = new HashMap<>(); - String textTbl = "public/ad_group_roles.tbl"; private void createDbGitIgnore(){ dbGitIgnore = new DBGitIgnore(filters, exclusions); - addExcl("public/*.*"); } private void addFilter(String mask){ filters.put(mask, new MaskFilter(mask)); } @@ -27,6 +25,9 @@ private void createDbGitIgnore(){ @Test public void matchOne() { createDbGitIgnore(); + addExcl("public/*.*"); + + final String textTbl = "public/ad_group_roles.tbl"; assertFalse(dbGitIgnore.matchOne(textTbl)); } -} \ No newline at end of file +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/ClassCompositionTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/ClassCompositionTest.java deleted file mode 100644 index bde1fc3..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/ClassCompositionTest.java +++ /dev/null @@ -1,200 +0,0 @@ -package ru.fusionsoft.dbgit.integration; - -import java.nio.file.Path; -import org.apache.commons.io.FileUtils; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; -import ru.fusionsoft.dbgit.integration.primitives.TestResult; -import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCloningGitRepo; -import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; -import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFiles; -import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; -import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; -import ru.fusionsoft.dbgit.integration.primitives.path.PathPrintsToConsole; -import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; -import ru.fusionsoft.dbgit.integration.primitives.DescribedTestResult; -import ru.fusionsoft.dbgit.integration.primitives.GrouppedTR; -import ru.fusionsoft.dbgit.integration.primitives.Patch; -import ru.fusionsoft.dbgit.integration.primitives.PatchSequental; -import ru.fusionsoft.dbgit.integration.primitives.SimpleTest; -import ru.fusionsoft.dbgit.integration.primitives.SimpleTestResult; - -public class ClassCompositionTest { - - @Test - public final void subjectSideEffectAppearsOnceWhenAccessingTwice() throws Exception { - Assertions.assertEquals( - 2, - new DescribedTestResult( - "Test result subject side effect appears once", - new SimpleTestResult( - new PathPrintsToConsole( - "Line printed as side effect...", - new ProjectTestResourcesCleanDirectoryPath( - "Test result subject side effect appears once" - ) - ), - subj -> { - subj.isAbsolute(); - subj.toString(); - subj.toFile(); - return true; - } - ) - ) - .text() - .split("\n") - .length - ); - } - - @Test - public final void failsToFalseOnException() { - final ProjectTestResourcesCleanDirectoryPath workingDirectory = - new ProjectTestResourcesCleanDirectoryPath( - "Fails to false on exception"); - - Assertions.assertDoesNotThrow( - () -> { - final TestResult testResult = - new DescribedTestResult( - "Fails to false on exception", - new SimpleTestResult( - new PathPatched( - new PathNotProjectRoot(workingDirectory), - new Patch() { - @Override - public void apply(Path root) throws Exception { - System.out.println("access " + root.toString()); - throw new Error( - "dummy error" - ); - } - } - ), - path -> { - path.toString(); - path.toString(); - path.toString(); - path.toString(); - return ! path - .resolve("pom.xml") - .toFile() - .exists(); - } - ) - ); - - System.out.println(testResult.text()); - Assertions.assertFalse(testResult.value()); - } - ); - } - - @Test - public final void groupedTestResultWorks() { - final DescribedTestResult result = new DescribedTestResult( - "Grouped test result works", - new GrouppedTR( - new ProjectTestResourcesCleanDirectoryPath( - "Grouped test result works" - ), - new SimpleTest<>( - "Retruns true", - (path) -> { - path.toString(); - return true; - } - ), - new SimpleTest<>( - "Throws exception", - (path) -> { - path.toString(); - throw new Exception("dummy expection"); - } - ), - new SimpleTest<>( - "Throws error", - (path) -> { - path.toString(); - throw new Error("dummy error the second"); - } - ) - ) - ); - System.out.println(result.text()); - Assertions.assertFalse(result.value()); - } - - @Test - public final void patchedWorks() { - final ProjectTestResourcesCleanDirectoryPath workingDirectory = - new ProjectTestResourcesCleanDirectoryPath( - "Patched works" - ); - - final String fileName = "testFile.txt"; - final String content = "content"; - - final DescribedTestResult result = new DescribedTestResult( - "Patched works", - new GrouppedTR<>( - new PathPatched( - new PathNotProjectRoot(workingDirectory), - new PathPatchCreatingFile(fileName, content) - ), - - new SimpleTest<>( - "Файл существует", - path -> { - return path.resolve(fileName).toFile().exists(); - } - ), - new SimpleTest<>( - "Содержимое файла как ожидалось", - path -> { - return FileUtils.readFileToString( - path.resolve(fileName).toFile() - ) - .contains(content); - } - ) - ) - ); - - System.out.println(result.text()); - Assertions.assertTrue(result.value()); - } - - @Test - public final void patchSequentalWorks() { - final DescribedTestResult result = new DescribedTestResult( - "Sequental patch works", - new SimpleTestResult<>( - new PathPatched( - new PathNotProjectRoot( - new ProjectTestResourcesCleanDirectoryPath( - "Sequental patch works" - ) - ), - new PatchSequental<>( - new PathPatchDeletingFiles(".git", ".dbgit"), - new PathPatchCloningGitRepo( - "https://github.com/rocket-3/dbgit-test.git", - "master" - ) - ) - ), - new SimpleTest<>( - "Git folder exists", - x -> x.resolve(".git").toFile().exists() - ) - ) - ); - - System.out.println(result.text()); - Assertions.assertTrue(result.value()); - - } - -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java new file mode 100644 index 0000000..bd12b9b --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java @@ -0,0 +1,340 @@ +package ru.fusionsoft.dbgit.integration; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import ru.fusionsoft.dbgit.integration.primitives.Patch; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitCheckout; +import ru.fusionsoft.dbgit.integration.primitives.DescribedTestResult; +import ru.fusionsoft.dbgit.integration.primitives.GroupedTestResult; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTest; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTestResult; +import ru.fusionsoft.dbgit.integration.primitives.TestResult; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLinkPgAuto; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemoteTestRepo; +import ru.fusionsoft.dbgit.integration.primitives.chars.CommitsFromRepo; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.CharsOfLines; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LinesOf; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckout; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitClonesRepo; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitReset; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitRestore; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfConsoleWhenRunning; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit.CharsDbIgnoreWithTableData; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.NameOfDefaultTargetTestDatabase; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.UrlOfGitTestRepo; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitAdd; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitInitializesRepo; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitLink; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; +import ru.fusionsoft.dbgit.integration.primitives.path.PathWithFiles; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.scenarios.PathAfterDbGitLinkAndAdd; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRun; +import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.PathWithDbGitRepoCloned; +import ru.fusionsoft.dbgit.integration.primitives.path.PathWithoutFiles; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; +import ru.fusionsoft.dbgit.integration.primitives.printstream.PrintStreamToConsole; + +@Tag("integration") +public class DbGitIntegrationTestBasic { + + @Test + public final void doesNothingIntegrationTestTemplate() { + final String description = "Does nothing test works"; + final TestResult result = + new GroupedTestResult<>( + description, + new PathPatched( + new ProjectTestResourcesCleanDirectoryPath("00"), + new Patch() { + @Override + public void apply(Path root) throws Exception { + + } + } + ), + new SimpleTest<>( + "Returns true", + (path) -> { + path.toString(); + return true; + } + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void gitToFilesCheckoutWorks() { + final String description = "Dbgit checkout and reset works"; + final String branchName = "dsdata"; + final String commitNameOfHead = "9e91d86"; + final String commitNameOfDs2 = "83baf51"; + final String fileName = ".dbgit/.dblink"; + final String reamdeFileName = "README.md"; + final String expectedFileContent = "ds2"; + final TestResult testResult = new GroupedTestResult<>( + description, + + new PathAfterDbGitRun( + new ArgsDbGitCheckout(commitNameOfDs2, "-nodb", "-v"), + + new PathAfterDbGitRun( + new ArgsDbGitCheckout(branchName, "-b", "-nodb", "-v"), + + new PathAfterDbGitRun( + new ArgsDbGitAddRemoteTestRepo("origin"), + + new PathWithDbGitRepoCloned( + new UrlOfGitTestRepo(), + new ProjectTestResourcesCleanDirectoryPath("01") + ) + ) + ) + ), + new SimpleTest<>( + "Printed expected commit hash", + (path) -> { + final CharSequence consoleOutput = new CharsOfConsoleWhenRunning(() -> { + new PathAfterDbGitRun(new ArgsExplicit("checkout", "-ls", "-v"), path).toString(); + }); + System.out.println(consoleOutput); + return new LinesOf(consoleOutput) + .list() + .stream() + .anyMatch(x -> x.contains(commitNameOfDs2)); + } + ), + new SimpleTest<>( + "File content of "+fileName+" is as expected", + (path) -> { + return Files.readAllLines(path.resolve(fileName)) + .stream() + .anyMatch(x->x.contains(expectedFileContent)); + } + ), + new SimpleTest<>( + "File "+reamdeFileName+" does not exists", + (path) -> { + return ! path.resolve("README.md").toFile().exists(); + } + ), + new SimpleTest<>( + "File "+reamdeFileName+" exists after checkout back to ", + (path) -> { + return new PathPatched( + new PatchSequential( + new PathPatchDbGitCheckout(branchName, "-nodb", "-v"), + new PathPatchDbGitCheckout("-ls", "-v") + ), + path + ).resolve(reamdeFileName).toFile().exists(); + } + ) + ); + + System.out.println(testResult.text()); + Assertions.assertTrue(testResult.value()); + } + + @Test + public final void dbToFilesDumpWorks() { + final String description = "Dbgit add with table data works"; + final TestResult result = new GroupedTestResult( + description, + + new PathAfterDbGitRun( + new ArgsExplicit("add", "\"*\""), + + new PathWithFiles( + new PathPatchCreatingFile(".dbgit/.dbignore", new CharsDbIgnoreWithTableData()), + + new PathAfterDbGitRun( + new ArgsDbGitLinkPgAuto("pagilla"), + + new PathAfterDbGitRun( + new ArgsExplicit("init"), + + new ProjectTestResourcesCleanDirectoryPath("02") + ) + ) + ) + ), + + new SimpleTest<>( + "git folder exists", + (path) -> { + return path.resolve(".git").toFile().exists(); + } + ), + new SimpleTest<>( + "rental table data exists", + (path) -> { + return path.resolve(".dbgit/public/rental.csv").toFile().exists(); + } + ), + new SimpleTest<>( + "'city' table data (small) is not empty", + (path) -> { + return ! Files.readAllLines(path.resolve(".dbgit/public/rental.csv")).isEmpty(); + } + ), + new SimpleTest<>( + "rental table data (10K+ rows) is not empty", + (path) -> { + return ! Files.readAllLines(path.resolve(".dbgit/public/rental.csv")).isEmpty(); + } + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void dbToDbRestoreWorks() { + final String nameOfSourceDb = "dsd3"; + final String nameOfTargetDb = new NameOfDefaultTargetTestDatabase().toString(); + final String description = + "Simple add from '" + nameOfSourceDb + "' db with data " + + "and restore to '" + nameOfTargetDb + "' db works"; + + final TestResult result = new GroupedTestResult<>( + description, + new PathPatched( + new PatchSequential( + new PathPatchDbGitInitializesRepo(new ArgsDbGitLinkPgAuto(nameOfSourceDb)), + new PathPatchCreatingFile(".dbgit/.dbignore", new CharsDbIgnoreWithTableData()), + new PathPatchDbGitAdd(), + new PathPatchDbGitLink(new ArgsDbGitLinkPgAuto(nameOfTargetDb)), + new PathPatchDbGitRestore("-r", "-v") + ), + new ProjectTestResourcesCleanDirectoryPath("03") + ), + new SimpleTest<>( + "Should not throw any exceptions", + (path) -> { + path.toString(); + return true; + } + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void gitToDbRestoreWorks() throws Exception { + + final String nameOfSourceBranch = "dsdata"; + final String description = + "Simple sequential checkout from '" + nameOfSourceBranch + "' branch " + + "and restore to '" + new NameOfDefaultTargetTestDatabase() + "' db works"; + + final List commitNames = new CommitsFromRepo( + new UrlOfGitTestRepo().toString(), nameOfSourceBranch + ).names(); + + final ArgsDbGitLinkPgAuto linkArgs = new ArgsDbGitLinkPgAuto(new NameOfDefaultTargetTestDatabase()); + final TestResult result = new GroupedTestResult<>( + description, + new PathPatched( + new PatchSequential( + new PathPatchDbGitClonesRepo(new UrlOfGitTestRepo(), new ArgsDbGitAddRemoteTestRepo()), + new PathPatchDbGitCheckout(nameOfSourceBranch, "-b", "-nodb"), + new PathPatchDbGitCheckout(commitNames.get(0), "-nodb", "-v"), + new PathPatchDbGitLink(linkArgs), + new PathPatchDbGitRestore("-r", "-v"), + new PathPatchDbGitCheckout(commitNames.get(1), "-nodb", "-v"), + new PathPatchDbGitLink(linkArgs), + new PathPatchDbGitRestore("-r", "-v"), + new PathPatchDbGitCheckout(commitNames.get(2), "-nodb", "-v"), + new PathPatchDbGitLink(linkArgs), + new PathPatchDbGitRestore("-r", "-v") + ), + new ProjectTestResourcesCleanDirectoryPath("04") + ), + new SimpleTest<>( + "Should not throw any exceptions", + (path) -> { + path.toString(); + return true; + } + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void dbToDbRestoreWorksWithCustomTypes() { + final String description = "Hardest sakilla_database sequential add and restore with table data and custom types (mpaa_rating) works"; + final TestResult result = new DescribedTestResult( + description, + new SimpleTestResult<>( + new PathAfterDbGitRun( + //pagilla to test#databasegit over dvdrental + new ArgsExplicit("restore", "-r", "-v"), + + new PathAfterDbGitRun( + new ArgsDbGitLinkPgAuto(new NameOfDefaultTargetTestDatabase()), + + //pagilla to local repo + new PathAfterDbGitLinkAndAdd( + new ArgsDbGitLinkPgAuto("pagilla"), + new CharsDbIgnoreWithTableData(), + + //dvdrental to test#databasegit + new PathAfterDbGitRun( + new ArgsExplicit("restore", "-r", "-v"), + + new PathAfterDbGitRun( + new ArgsDbGitLinkPgAuto(new NameOfDefaultTargetTestDatabase()), + + //dvdrental to local repo + new PathAfterDbGitLinkAndAdd( + new ArgsDbGitLinkPgAuto("dvdrental"), + new CharsDbIgnoreWithTableData(), + + new PathAfterDbGitRun( + new ArgsExplicit("init"), + + new PathWithoutFiles( + "*", + new PathNotProjectRoot( + new ProjectTestResourcesCleanDirectoryPath("05") + ) + ) + ) + ) + ) + ) + ) + ) + ), + new SimpleTest<>( + "Should not throw any exceptions", + (path) -> { + path.toString(); + return true; + } + ) + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestExtendedCommands.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestExtendedCommands.java new file mode 100644 index 0000000..8124cfc --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestExtendedCommands.java @@ -0,0 +1,7 @@ +package ru.fusionsoft.dbgit.integration; + +import org.junit.jupiter.api.Tag; + +@Tag("integration") +public class DbGitIntegrationTestExtendedCommands { +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestNotebook.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestNotebook.java new file mode 100644 index 0000000..b60b53c --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestNotebook.java @@ -0,0 +1,146 @@ +package ru.fusionsoft.dbgit.integration; + +import java.nio.file.Path; +import java.text.MessageFormat; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLinkPgAuto; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningGit; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchGitCheckoutOrphan; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRun; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterGitRun; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.scenarios.PathAfterDbGitLinkAndAdd; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.PathWithDbGitRepoCloned; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.DescribedTestResult; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTest; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTestResult; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemoteTestRepo; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLinkPgLocal; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit.CharsDbIgnoreWithTableData; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.UrlOfGitTestRepo; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckout; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.scenarios.PathAfterDbGitDumpsDbSchemaToGit; + +@Tag("notebook") +public class DbGitIntegrationTestNotebook { + @Test + public final void appendsDbSchemaToBranchOfTestRepo() { + final String description = "Appends db schema to existing git branch"; + final String nameOfBranchToAppendTo = "sakilla-data"; + final String nameOfDbToDump = "dvdrental"; + final String nameOfRemote = "origin-test"; + final CharSequence ignoreChars = new CharsDbIgnoreWithTableData(); + final DescribedTestResult result = new DescribedTestResult<>( + description, + new SimpleTestResult<>( + new PathAfterDbGitDumpsDbSchemaToGit( + nameOfDbToDump, + nameOfRemote, + new UrlOfGitTestRepo(), + new ArgsDbGitLinkPgLocal(nameOfDbToDump), + new ArgsDbGitAddRemoteTestRepo(nameOfRemote), + ignoreChars, + new PathPatchDbGitCheckout( + nameOfBranchToAppendTo, + "-b", + "-nodb", + "-v" + ), + new DefaultPrintStream(), + new ProjectTestResourcesCleanDirectoryPath(description) + ), + new SimpleTest<>( + (path) -> { + return path.resolve(".dbgit/public/rental.csv").toFile().exists(); + } + ) + ) + ); + + System.out.println("\n" + result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void dumpsDbSchemaToNewBranchOfTestRepo() { + final String nameOfNewBranch = "sakilla-data"; + final String nameOfDbToDump = "pagilla"; + final String nameOfRemote = "origin-test"; + final String description = "Dumps db schema to new git branch"; + final CharSequence ignoreChars = new CharsDbIgnoreWithTableData(); + + new PathAfterGitRun( + new ArgsExplicit("push", nameOfRemote, nameOfNewBranch, "-v"), + + new PathAfterDbGitRun( + new ArgsExplicit("commit", "-m", nameOfDbToDump), + + new PathAfterDbGitLinkAndAdd( + new ArgsDbGitLinkPgAuto(nameOfDbToDump), + ignoreChars, + + new PathPatched( + new PathPatchGitCheckoutOrphan(nameOfNewBranch), + + new PathAfterDbGitRun( + new ArgsDbGitAddRemoteTestRepo(nameOfRemote), + + new PathWithDbGitRepoCloned( + new UrlOfGitTestRepo(), + + new ProjectTestResourcesCleanDirectoryPath( + description + ) + ) + ) + ) + ) + ) + ).toString(); + + } + + @Test + public final void cleansBranch() { + final String branchToClean = "master"; + final String nameOfNewBranch = "orphan"; + final String nameOfRemote = "origin"; + final String description = "Replaces branch " + + branchToClean + + " with a new git branch"; + + new PathPatched( + new PatchSequential<>( + new PathPatchGitCheckoutOrphan(nameOfNewBranch), + new PathPatchCreatingFile("readme.md", "Just a clean branch"), + new PathPatchRunningGit("add", "readme.md"), + new PathPatchRunningGit("commit", "-m", "\"clean branch\""), + new PathPatchRunningGit("push", nameOfRemote, + MessageFormat.format( + "+{0}:{1}", nameOfNewBranch, branchToClean + ) + ) + ), + new PathAfterDbGitRun( + new ArgsDbGitAddRemoteTestRepo(nameOfRemote), + + new PathWithDbGitRepoCloned( + new UrlOfGitTestRepo(), + new ProjectTestResourcesCleanDirectoryPath( + description + ) + ) + ) + + ).toString(); + + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitTest.java deleted file mode 100644 index dc425d5..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitTest.java +++ /dev/null @@ -1,434 +0,0 @@ -package ru.fusionsoft.dbgit.integration; - -import java.nio.file.Path; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Tag; -import org.junit.jupiter.api.Test; -import ru.fusionsoft.dbgit.integration.primitives.DescribedTestResult; -import ru.fusionsoft.dbgit.integration.primitives.SimpleTest; -import ru.fusionsoft.dbgit.integration.primitives.SimpleTestResult; -import ru.fusionsoft.dbgit.integration.primitives.TestResult; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsCheckoutNodb; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; -import ru.fusionsoft.dbgit.integration.primitives.args.specific.AutoPgLinkArgs; -import ru.fusionsoft.dbgit.integration.primitives.args.specific.GitTestRepoAddRemoteArgs; -import ru.fusionsoft.dbgit.integration.primitives.chars.SavedConsoleText; -import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; -import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRestore; -import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRun; -import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; -import ru.fusionsoft.dbgit.integration.primitives.path.PathWithBuildingDbGitExecutableFromGit; -import ru.fusionsoft.dbgit.integration.primitives.path.PathWithDbGitRepoInitialized; -import ru.fusionsoft.dbgit.integration.primitives.path.PathWithFiles; -import ru.fusionsoft.dbgit.integration.primitives.path.PathWithoutFiles; -import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; - -@Tag("integration") -public class DbGitTest { - - @Test - public final void clonesRepoAndReturnsCurrentCommitNumber() throws Exception { - final Path workingDirectory = - new ProjectTestResourcesCleanDirectoryPath( - "Clones repo and prints expected commit hash") - .toAbsolutePath(); - - final String commitHash = "b1fecd7"; - - final TestResult testResult = new DescribedTestResult<>( - "Dbgit clone works as expected", - new SavedConsoleText( - () -> { - new PathAfterDbGitRun( - new ArgsExplicit( - "checkout", - "-ls", "-v" - ), - System.out, - new PathAfterDbGitRun( - new ArgsExplicit( - "checkout", - "master", - commitHash, - "-nodb" - ), - new PathAfterDbGitRun( - new GitTestRepoAddRemoteArgs("origin"), - - new PathAfterDbGitRun( - new ArgsExplicit("init"), - - new PathAfterDbGitRun( - new ArgsExplicit( - "clone", - "https://github.com/rocket-3/dbgit-test.git", - "--directory", - "\"" + workingDirectory - .toString() + "\"" - ), - - new PathWithoutFiles( - "*", - new PathNotProjectRoot( - workingDirectory - ) - ) - ) - ) - ) - ) - ).toString(); - } - ), - new SimpleTest( - "Printed expected commit hash", - (text) -> { - return text - .lines() - .stream() - .anyMatch( - (line) -> line.contains(commitHash) - ); - } - ) - ); - - System.out.println(testResult.text()); - Assertions.assertTrue(testResult.value()); - } - - @Test - public final void fetchesDatabaseObjects() { - final Path workingDirectory = - new ProjectTestResourcesCleanDirectoryPath("fetchesDatabaseObjects") - .toAbsolutePath(); - - final DescribedTestResult result = new DescribedTestResult<>( - "Dbgit add command test", - new SimpleTestResult<>( - new PathAfterDbGitRun( - new ArgsExplicit("add", "\"*\""), - new PathAfterDbGitRun( - new AutoPgLinkArgs("pagilla"), - new PathAfterDbGitRun( - new ArgsExplicit("init"), - new PathWithoutFiles( - "*", - new PathNotProjectRoot( - workingDirectory - ) - ) - ) - ) - ), - new SimpleTest<>( - (path) -> { - return path.resolve(".git").toFile().exists(); - } - ) - ) - ); - - System.out.println("\n" + result.text()); - Assertions.assertTrue(result.value()); - } - - @Test - public final void fetchesAndCommitsWholeNewStructure() { - final Path workingDirectory = - new ProjectTestResourcesCleanDirectoryPath( - "fetchesAndCommitsWholeNewStructure") - .toAbsolutePath(); - - final DescribedTestResult result = new DescribedTestResult( - "Dbgit add command test", - new SimpleTestResult<>( - new PathAfterDbGitRun( - new ArgsExplicit("push"), - new PathAfterDbGitRun( - new ArgsExplicit( - "commit", - "-m", - "Pagilla database" - ), - new PathAfterDbGitRun( - new ArgsExplicit("add", "\"*\""), - // dbgit rm -idx - // can't work without MetaFile parsing, which - // is unstable during current development - //new PathAfterAppRunInProcess(new ExplicitArgs("rm","\"*\"", "-idx"), - new PathWithFiles( - new PathPatchCreatingFile( - ".dbgit/.dbindex", - "version=0.3.1" - ), - new PathWithoutFiles( - new String[]{".dbgit/public"}, - new PathAfterDbGitRun( - new ArgsExplicit( - "checkout", - "ng", - "-nodb" - ), - new PathAfterDbGitRun( - new AutoPgLinkArgs("dvdrental"), - new PathAfterDbGitRun( - new ArgsExplicit( - "checkout", - "master", - "-nodb" - ), - new PathAfterDbGitRun( - new GitTestRepoAddRemoteArgs("origin"), - new PathAfterDbGitRun( - new ArgsExplicit("init"), - new PathAfterDbGitRun( - new ArgsExplicit( - "clone", - "https://github.com/rocket-3/dbgit-test.git", - "--directory", - "\"" - + workingDirectory - .toString() - + "\"" - ), - new PathWithoutFiles( - "*", - new PathNotProjectRoot( - workingDirectory - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - - ), - new SimpleTest<>( - (path) -> { - return path.resolve(".git").toFile().exists(); - } - ) - ) - ); - - System.out.println("\n" + result.text()); - Assertions.assertTrue(result.value()); - } - - @Test - public final void commitsLilChangedDbSchema() { - final Path workingDirectory = - new ProjectTestResourcesCleanDirectoryPath( - "commitsLilChangedDbSchema") - .toAbsolutePath(); - - final DescribedTestResult result = new DescribedTestResult<>( - "Dbgit add command test", - new SimpleTestResult<>( - new PathAfterDbGitRun( - new ArgsExplicit( - "push" - ), - - new PathAfterDbGitRun( - new ArgsExplicit( - "commit", - "-m", - "Sakilla database" - ), - - new PathAfterDbGitRun( - new ArgsExplicit( - "add", - "\"*\"" - ), - - new PathAfterDbGitRun( - new AutoPgLinkArgs("dvdrental"), - - new PathAfterDbGitRun( - new ArgsExplicit( - "checkout", - "ng", - "-nodb" - ), - - new PathAfterDbGitRun( - new GitTestRepoAddRemoteArgs("origin"), - - new PathAfterDbGitRun( - new ArgsExplicit("init"), - - new PathAfterDbGitRun( - new ArgsExplicit( - "clone", - "https://github.com/rocket-3/dbgit-test.git", - "--directory", - "\"" + workingDirectory - .toString() + "\"" - ), - - new PathWithoutFiles( - "*", - new PathNotProjectRoot( - workingDirectory - ) - ) - ) - ) - ) - ) - - ) - ) - ) - - ), - new SimpleTest<>( - (path) -> { - return path.resolve(".git").toFile().exists(); - } - ) - ) - ); - - System.out.println("\n" + result.text()); - Assertions.assertTrue(result.value()); - - } - - @Test - public final void usesAnotherDbGitVersionToRestore() { - - final Path olderDbGitExecutablePath = new PathWithBuildingDbGitExecutableFromGit( - "51e8fa0", - new ProjectTestResourcesCleanDirectoryPath("dbgit version 51e8fa0") - ); - final ArgsLink testDbLinkArgsMoniker = new AutoPgLinkArgs("test#databasegit"); - final TestResult result = new DescribedTestResult<>( - "Uses older dbgit version to prepare database", - new SimpleTestResult<>( - new PathAfterDbGitRestore( - new ArgsCheckoutNodb("master", "8867384"), - testDbLinkArgsMoniker, - olderDbGitExecutablePath, - new PathAfterDbGitRestore( - new ArgsCheckoutNodb("master", "b1fecd7"), - testDbLinkArgsMoniker, - olderDbGitExecutablePath, - new PathAfterDbGitRestore( - new ArgsCheckoutNodb("master", "831054e"), - testDbLinkArgsMoniker, - olderDbGitExecutablePath, - new PathAfterDbGitRestore( - new ArgsCheckoutNodb("master", "d2b4080"), - testDbLinkArgsMoniker, - olderDbGitExecutablePath, - - new PathAfterDbGitRestore( - new ArgsCheckoutNodb("master", "4f3953d"), - testDbLinkArgsMoniker, - olderDbGitExecutablePath, - - new PathWithDbGitRepoInitialized( - "https://github.com/rocket-3/dbgit-test.git", - - new ProjectTestResourcesCleanDirectoryPath( - "usesAnotherDbGitVersionToRestore" - ) - ) - ) - ) - ) - ) - ), - new SimpleTest<>( - "Exception not thrown", - (path) -> { - path.toString(); - return true; - } - ) - ) - ); - - System.out.println(result.text()); - Assertions.assertTrue(result.value()); - } - - @Test - public final void createsAndUpdatesDatabase() { - final String description = "Fills and updates database from different repos"; - final Path workingDirectory = new ProjectTestResourcesCleanDirectoryPath( - description - ) - .toAbsolutePath(); - - - final TestResult result = new DescribedTestResult( - description, - new SimpleTestResult<>( - new PathAfterDbGitRun( - new ArgsExplicit("restore", "-r", "-v"), - - new PathAfterDbGitRun( - new AutoPgLinkArgs("test#databasegit"), - - new PathAfterDbGitRun( - new ArgsExplicit("add", "\"*\""), - - new PathAfterDbGitRun( - new AutoPgLinkArgs("pagilla"), - new PathAfterDbGitRun( - new ArgsExplicit("restore", "-r", "-v"), - System.out, - new PathAfterDbGitRun( - new AutoPgLinkArgs("test#databasegit"), - - new PathAfterDbGitRun( - new ArgsExplicit("add", "\"*\""), - - new PathAfterDbGitRun( - new AutoPgLinkArgs("dvdrental"), - - new PathAfterDbGitRun( - new ArgsExplicit("init"), - - new PathWithoutFiles( - "*", - new PathNotProjectRoot( - workingDirectory - ) - ) - ) - ) - ) - ) - ) - ) - ) - ) - ), - new SimpleTest<>( - "Exception not thrown", - (path) -> { - path.toString(); - return true; - } - ) - ) - ); - - System.out.println(result.text()); - Assertions.assertTrue(result.value()); - } - -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java new file mode 100644 index 0000000..78388e6 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java @@ -0,0 +1,196 @@ +package ru.fusionsoft.dbgit.integration; + +import java.nio.file.Path; +import org.apache.commons.io.FileUtils; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import ru.fusionsoft.dbgit.integration.primitives.TestResult; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; +import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPrintsToConsole; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; +import ru.fusionsoft.dbgit.integration.primitives.DescribedTestResult; +import ru.fusionsoft.dbgit.integration.primitives.GroupedTestResult; +import ru.fusionsoft.dbgit.integration.primitives.Patch; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTest; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTestResult; + +public class SelfTest { + + @Test + public final void subjectSideEffectAppearsOnceWhenAccessingTwice() throws Exception { + Assertions.assertEquals( + 2, + new DescribedTestResult( + "Test result subject side effect appears once", + new SimpleTestResult( + new PathPrintsToConsole( + "Line printed as side effect...", + new ProjectTestResourcesCleanDirectoryPath( + "Test result subject side effect appears once" + ) + ), + new SimpleTest<>(subj -> { + subj.isAbsolute(); + subj.toString(); + subj.toFile(); + return true; + }) + ) + ) + .text() + .split("\n") + .length + ); + } + + @Test + public final void failsToFalseOnException() { + final ProjectTestResourcesCleanDirectoryPath workingDirectory = + new ProjectTestResourcesCleanDirectoryPath( + "Fails to false on exception"); + + Assertions.assertDoesNotThrow( + () -> { + final TestResult testResult = + new DescribedTestResult( + "Fails to false on exception", + new SimpleTestResult( + new PathPatched( + new PathNotProjectRoot(workingDirectory), + new Patch() { + @Override + public void apply(Path root) throws Exception { + System.out.println("access " + + root.toString()); + throw new Error( + "dummy error" + ); + } + } + ), + new SimpleTest<>(path -> { + path.toString(); + path.toString(); + path.toString(); + path.toString(); + return ! path + .resolve("pom.xml") + .toFile() + .exists(); + }) + ) + ); + + System.out.println(testResult.text()); + Assertions.assertFalse(testResult.value()); + } + ); + } + + @Test + public final void groupedTestResultWorks() { + final TestResult result = new GroupedTestResult( + "Grouped test result works", + new ProjectTestResourcesCleanDirectoryPath( + "Grouped test result works" + ), + new SimpleTest( + "Retruns true", + (path) -> { + path.toString(); + return true; + } + ), + new SimpleTest<>( + "Throws exception", + (path) -> { + path.toString(); + throw new Exception("dummy expection"); + } + ), + new SimpleTest<>( + "Throws error", + (path) -> { + path.toString(); + throw new Error("dummy error the second"); + } + ) + ); + System.out.println(result.text()); + Assertions.assertFalse(result.value()); + } + + @Test + public final void patchedWorks() { + final ProjectTestResourcesCleanDirectoryPath workingDirectory = + new ProjectTestResourcesCleanDirectoryPath( + "Patched works" + ); + + final String fileName = "testFile.txt"; + final String content = "content"; + + final TestResult result = new GroupedTestResult<>( + "Patched works", + new PathPatched( + new PathNotProjectRoot(workingDirectory), + new PathPatchCreatingFile(fileName, content) + ), + + new SimpleTest<>( + "Файл существует", + path -> { + return path.resolve(fileName).toFile().exists(); + } + ), + new SimpleTest<>( + "Содержимое файла как ожидалось", + path -> { + return FileUtils.readFileToString( + path.resolve(fileName).toFile() + ) + .contains(content); + } + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + } + + @Test + public final void patchSequentalWorks() { + final String fileName = "abc.txt"; + final String fileContent = "cba"; + final DescribedTestResult result = new DescribedTestResult( + "Sequental patch works", + new SimpleTestResult<>( + new PathPatched( + new PathNotProjectRoot( + new ProjectTestResourcesCleanDirectoryPath( + "Sequental patch works" + ) + ), + new PatchSequential<>( + new PathPatchCreatingFile(fileName, "abc"), + new PathPatchCreatingFile(fileName, fileContent) + ) + ), + new SimpleTest<>( + "File content is as expected", + x -> FileUtils.readFileToString(x.resolve(fileName).toFile()) + .equals(fileContent) + + ) + ) + ); + + System.out.println(result.text()); + Assertions.assertTrue(result.value()); + + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterExecutableRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterExecutableRun.java index 8d4c1fd..3950d14 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterExecutableRun.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/deprecated/PathAfterExecutableRun.java @@ -3,11 +3,11 @@ import java.io.PrintStream; import java.nio.file.Path; import ru.fusionsoft.dbgit.integration.primitives.Args; -import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithPrepend; import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; -import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterCommandRun; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterProcessRun; import ru.fusionsoft.dbgit.integration.primitives.path.PathEnvelope; public class PathAfterExecutableRun extends PathEnvelope { @@ -20,7 +20,7 @@ public PathAfterExecutableRun( ) { super( () -> - new PathAfterCommandRun( + new PathAfterProcessRun( new ArgsWithPrepend( new ArgsWithPrepend( command, @@ -44,7 +44,7 @@ public PathAfterExecutableRun( commandInterface, executableName, executableArgs, - new NullPrintStream(), + new DefaultPrintStream(), workingDirectory ); } @@ -72,7 +72,7 @@ public PathAfterExecutableRun( this( executableName, args, - new NullPrintStream(), + new DefaultPrintStream(), workingDirectory ); } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/DescribedTestResult.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/DescribedTestResult.java index 26ac91e..a99af00 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/DescribedTestResult.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/DescribedTestResult.java @@ -1,20 +1,19 @@ package ru.fusionsoft.dbgit.integration.primitives; import java.text.MessageFormat; -import java.util.regex.Pattern; -import ru.fusionsoft.dbgit.integration.primitives.chars.TestSuccessMarkChars; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsQuotedToRegexPattern; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LabelOfTestRunResult; public class DescribedTestResult implements TestResult { private final String description; private final TestResult testResult; - public DescribedTestResult(String description, Subj subject, Test test) { + public DescribedTestResult(String description, TestResult testResult) { this.description = description; - this.testResult = new SimpleTestResult<>(subject, test); + this.testResult = testResult; } - - public DescribedTestResult(String description, TestResult simpleTestResult) { - this.description = description; - this.testResult = simpleTestResult; + + public DescribedTestResult(String description, Subj subject, Test test) { + this(description, new SimpleTestResult<>(subject, test)); } @Override @@ -24,16 +23,16 @@ public final boolean value() { @Override public final String text() { - final String valueChars = String.valueOf( - new TestSuccessMarkChars(this.testResult.value()) + final CharSequence valueChars = new CharsQuotedToRegexPattern( + new LabelOfTestRunResult(this.testResult.value()) ); return this.testResult .text() .replaceFirst( - Pattern.quote(valueChars), + String.valueOf(valueChars), MessageFormat.format( - "{0} {1} -", + "{0} {1}", valueChars, this.description ) diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GroupedTestResult.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GroupedTestResult.java new file mode 100644 index 0000000..38836ec --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GroupedTestResult.java @@ -0,0 +1,27 @@ +package ru.fusionsoft.dbgit.integration.primitives; + +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LabelOfTestRunResult; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LinesOfString; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.ReportOfTestGroupRun; + +public class GroupedTestResult implements TestResult { + private final CharSequence text; + + @SafeVarargs + public GroupedTestResult(CharSequence description, Subj subject, Test... tests ) { + this.text = new ReportOfTestGroupRun<>(description, subject, tests); + } + + @Override + public final boolean value() { + return new LinesOfString( + String.valueOf(this.text) + ).list().get(0) + .contains(new LabelOfTestRunResult(true)); + } + + @Override + public final String text() { + return String.valueOf(this.text); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GrouppedTR.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GrouppedTR.java deleted file mode 100644 index fe30692..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GrouppedTR.java +++ /dev/null @@ -1,34 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives; - -import java.util.Arrays; -import java.util.Collection; -import java.util.stream.Collectors; -import ru.fusionsoft.dbgit.integration.primitives.chars.TestSuccessMarkChars; - -public class GrouppedTR implements TestResult { - private final Collection testResults; - - @SafeVarargs - public GrouppedTR(Subj subject, Test... tests ) { - this.testResults = Arrays.stream(tests) - .map(test -> new SimpleTestResult<>(subject, test)) - .collect(Collectors.toList()); - } - - @Override - public final boolean value() { - return testResults - .stream() - .allMatch(TestResult::value); - } - - @Override - public final String text() { - return new TestSuccessMarkChars(this.value()) - + "\n\t" - + testResults - .stream() - .map(TestResult::text) - .collect(Collectors.joining("\t")); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/NullPrintStream.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/NullPrintStream.java deleted file mode 100644 index 4da0621..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/NullPrintStream.java +++ /dev/null @@ -1,14 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives; - -import java.io.OutputStream; -import java.io.PrintStream; - -public class NullPrintStream extends PrintStream { - - public NullPrintStream() { - super(new OutputStream() { - @Override - public void write (int b) { } - }); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequental.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequential.java similarity index 71% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequental.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequential.java index 3226aa9..6fd4353 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequental.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/PatchSequential.java @@ -3,15 +3,15 @@ import java.util.Arrays; import java.util.Collection; -public class PatchSequental implements Patch { +public class PatchSequential implements Patch { private final Collection> patches; - public PatchSequental(final Collection> patches) { + public PatchSequential(final Collection> patches) { this.patches = patches; } @SafeVarargs - public PatchSequental(final Patch... patches) { + public PatchSequential(final Patch... patches) { this(Arrays.asList(patches)); } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalarOf.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalarOf.java index f931413..82eb6bb 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalarOf.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SafeScalarOf.java @@ -16,10 +16,13 @@ public final Y value() { try { return origin.value(); } catch (Exception e) { - throw new Error( - "Exception occurs while constructing safe scalar value", - e - ); + throw new SafeScalarError(e); + } + } + + public static class SafeScalarError extends Error { + public SafeScalarError(Throwable cause) { + super("Error occurs while constructing safe scalar value", cause); } } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTestResult.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTestResult.java index 6bc0f75..0285828 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTestResult.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/SimpleTestResult.java @@ -1,18 +1,12 @@ package ru.fusionsoft.dbgit.integration.primitives; -import ru.fusionsoft.dbgit.integration.primitives.chars.TestSuccessMarkChars; -import ru.fusionsoft.dbgit.integration.primitives.chars.TestResultDetailedChars; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LabelOfTestRunResult; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.ReportOfTestRun; public class SimpleTestResult implements TestResult { - private final CharSequence text; - public SimpleTestResult(Subj subject, Test test) { - this.text = new TestResultDetailedChars<>(subject, test); - } - - public SimpleTestResult(Subj subject, Function testFunction) { - this.text = new TestResultDetailedChars<>(subject, new SimpleTest<>(testFunction)); + this.text = new ReportOfTestRun<>(subject, test); } @Override @@ -22,8 +16,8 @@ public final String text() { @Override public final boolean value() { - return this.text().contains( - String.valueOf(new TestSuccessMarkChars(true)) - ); + return this + .text() + .contains(String.valueOf(new LabelOfTestRunResult(true))); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsCheckoutNodb.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsCheckoutNodb.java deleted file mode 100644 index 0d56e91..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsCheckoutNodb.java +++ /dev/null @@ -1,12 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.args; -public class ArgsCheckoutNodb extends ArgsExplicit { - - public ArgsCheckoutNodb(String branchName, String commitHash) { - super( - "checkout", - branchName, - commitHash, - "-nodb" - ); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java index f8bff8f..f620a85 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java @@ -11,7 +11,7 @@ public ArgsRunningCommand(CharSequence commandName) { "/C", commandName ); - } + } public ArgsRunningCommand(Path executablePath) { this( new CharsOf<>( @@ -20,12 +20,5 @@ public ArgsRunningCommand(Path executablePath) { ) ); } - public ArgsRunningCommand(Path executablePath, Path workingDirectory) { - this( - new PathRelativeTo( - workingDirectory, - executablePath - ) - ); - } + } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAdd.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAdd.java new file mode 100644 index 0000000..f8d8def --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAdd.java @@ -0,0 +1,13 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithPrepend; + +public class ArgsDbGitAdd extends ArgsWithPrepend { + public ArgsDbGitAdd(CharSequence mask) { + super(new ArgsExplicit(mask), "add", "-v"); + } + public ArgsDbGitAdd() { + this("\"*\""); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsDbGitAddRemote.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAddRemote.java similarity index 70% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsDbGitAddRemote.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAddRemote.java index 9bce2a4..0d8ffc4 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsDbGitAddRemote.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAddRemote.java @@ -1,4 +1,6 @@ -package ru.fusionsoft.dbgit.integration.primitives.args; +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; public class ArgsDbGitAddRemote extends ArgsExplicit { public ArgsDbGitAddRemote(String url, String name, String user, String pass) { diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAddRemoteTestRepo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAddRemoteTestRepo.java new file mode 100644 index 0000000..126f1e1 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitAddRemoteTestRepo.java @@ -0,0 +1,24 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.CredsOfGitTestRepo; + +public class ArgsDbGitAddRemoteTestRepo extends ArgsDbGitAddRemote { + public ArgsDbGitAddRemoteTestRepo(String url, String name, String user, String pass) { + super(url, name, user, pass); + } + public ArgsDbGitAddRemoteTestRepo(String url, String name, Credentials credentials) { + this(url, name, credentials.username(), credentials.password()); + } + public ArgsDbGitAddRemoteTestRepo(String name) { + this( + "github.com/rocket-3/dbgit-test.git", + name, + new CredsOfGitTestRepo() + ); + } + public ArgsDbGitAddRemoteTestRepo() { + this("origin"); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitCheckout.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitCheckout.java new file mode 100644 index 0000000..986cbbb --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitCheckout.java @@ -0,0 +1,16 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithAppend; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithPrepend; + +public class ArgsDbGitCheckout extends ArgsWithPrepend { + + public ArgsDbGitCheckout(CharSequence... args) { + super( + new ArgsExplicit(args), + "checkout" + ); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitClone.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitClone.java new file mode 100644 index 0000000..e642d97 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitClone.java @@ -0,0 +1,18 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; + +public class ArgsDbGitClone extends ArgsExplicit { + public ArgsDbGitClone(CharSequence repoUrl, CharSequence directoryToCloneToChars) { + super("clone", repoUrl, "--directory", "\"" + directoryToCloneToChars + "\""); + } + public ArgsDbGitClone(CharSequence repoUrl, Path directoryToCloneTo) { + this(repoUrl, new CharsOf<>(()->directoryToCloneTo.toAbsolutePath().toString())); + } + public ArgsDbGitClone(CharSequence repoUrl) { + this(repoUrl, "."); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitInit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitInit.java new file mode 100644 index 0000000..c3b76eb --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitInit.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; + +public class ArgsDbGitInit extends ArgsExplicit { + public ArgsDbGitInit() { + super("init"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsLink.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLink.java similarity index 68% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsLink.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLink.java index 285e7e8..596a4e8 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsLink.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLink.java @@ -1,24 +1,19 @@ -package ru.fusionsoft.dbgit.integration.primitives.args; +package ru.fusionsoft.dbgit.integration.primitives.args.specific; import ru.fusionsoft.dbgit.integration.primitives.Args; import ru.fusionsoft.dbgit.integration.primitives.SafeScalar; import ru.fusionsoft.dbgit.integration.primitives.SafeScalarOf; import ru.fusionsoft.dbgit.integration.primitives.Scalar; import ru.fusionsoft.dbgit.integration.primitives.StickyScalar; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; -public class ArgsLink implements Args { - +public class ArgsDbGitLink implements Args { private final SafeScalar argsScalar; - public ArgsLink(Scalar orign) { - this.argsScalar = new SafeScalarOf(new StickyScalar<>(orign)); - } - - @Override - public final CharSequence[] values() { - return argsScalar.value().values(); + public ArgsDbGitLink(Scalar origin) { + this.argsScalar = new SafeScalarOf(new StickyScalar<>(origin)); } - public ArgsLink(String url, String database, String user, String pass) { + public ArgsDbGitLink(CharSequence url, CharSequence database, CharSequence user, CharSequence pass) { this(()-> { return new ArgsExplicit( "link", @@ -28,5 +23,9 @@ public ArgsLink(String url, String database, String user, String pass) { ); }); } + @Override + public final CharSequence[] values() { + return argsScalar.value().values(); + } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgAuto.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgAuto.java new file mode 100644 index 0000000..afa53be --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgAuto.java @@ -0,0 +1,7 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +public class ArgsDbGitLinkPgAuto extends ArgsDbGitLink { + public ArgsDbGitLinkPgAuto(CharSequence databaseName) { + super(()->new ArgsDbGitLinkPgRemote(databaseName)); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/LocalPgLinkArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgLocal.java similarity index 52% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/LocalPgLinkArgs.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgLocal.java index 0b77876..6a701db 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/LocalPgLinkArgs.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgLocal.java @@ -1,11 +1,10 @@ package ru.fusionsoft.dbgit.integration.primitives.args.specific; import ru.fusionsoft.dbgit.integration.primitives.Credentials; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; -import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.PgCredentials; +import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.CredsOfPgTestDatabase; -public class LocalPgLinkArgs extends ArgsLink { - public LocalPgLinkArgs(String database, String user, String pass) { +public class ArgsDbGitLinkPgLocal extends ArgsDbGitLink { + public ArgsDbGitLinkPgLocal(CharSequence database, CharSequence user, CharSequence pass) { super( "jdbc:postgresql://localhost", database, @@ -14,10 +13,10 @@ public LocalPgLinkArgs(String database, String user, String pass) { ); } - public LocalPgLinkArgs(String database, Credentials credentials) { + public ArgsDbGitLinkPgLocal(CharSequence database, Credentials credentials) { this(database, credentials.username(), credentials.password()); } - public LocalPgLinkArgs(String database) { - this(database, new PgCredentials()); + public ArgsDbGitLinkPgLocal(CharSequence database) { + this(database, new CredsOfPgTestDatabase()); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgRemote.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgRemote.java new file mode 100644 index 0000000..9731bdf --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitLinkPgRemote.java @@ -0,0 +1,26 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.CredsOfPgTestDatabase; + +public class ArgsDbGitLinkPgRemote extends ArgsDbGitLink { + public ArgsDbGitLinkPgRemote(CharSequence database, CharSequence username, CharSequence password) { + super( + "jdbc:postgresql://135.181.94.98:31007", + database, + username, + password + ); + } + + public ArgsDbGitLinkPgRemote(CharSequence database, Credentials credentials) { + this(database, credentials.username(), credentials.password()); + } + + public ArgsDbGitLinkPgRemote(CharSequence database) { + this( + database, + new CredsOfPgTestDatabase() + ); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitReset.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitReset.java new file mode 100644 index 0000000..0c20019 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitReset.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithPrepend; + +public class ArgsDbGitReset extends ArgsWithPrepend { + public ArgsDbGitReset(CharSequence nameOfResetMode) { + super(new ArgsExplicit(nameOfResetMode), "reset"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitRestore.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitRestore.java new file mode 100644 index 0000000..edb3b57 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/ArgsDbGitRestore.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.primitives.args.specific; + +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithPrepend; + +public class ArgsDbGitRestore extends ArgsWithPrepend { + public ArgsDbGitRestore(CharSequence... restoreCommandArgs) { + super(new ArgsExplicit(restoreCommandArgs), "restore"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java deleted file mode 100644 index 821df06..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/AutoPgLinkArgs.java +++ /dev/null @@ -1,10 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.args.specific; - -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; - -public class AutoPgLinkArgs extends ArgsLink { - public AutoPgLinkArgs(String database) { - super(()->new DedicatedPgLinkArgs(database)); - } - -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/DedicatedPgLinkArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/DedicatedPgLinkArgs.java deleted file mode 100644 index 67c9cd1..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/DedicatedPgLinkArgs.java +++ /dev/null @@ -1,27 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.args.specific; - -import ru.fusionsoft.dbgit.integration.primitives.Credentials; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; -import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.PgCredentials; - -public class DedicatedPgLinkArgs extends ArgsLink { - public DedicatedPgLinkArgs(String database, String username, String password) { - super( - "jdbc:postgresql://135.181.94.98:31007/", - database, - username, - password - ); - } - - public DedicatedPgLinkArgs(String database, Credentials credentials) { - this(database, credentials.username(), credentials.password()); - } - - public DedicatedPgLinkArgs(String database) { - this( - database, - new PgCredentials() - ); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/GitTestRepoAddRemoteArgs.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/GitTestRepoAddRemoteArgs.java deleted file mode 100644 index 7d05bb3..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/specific/GitTestRepoAddRemoteArgs.java +++ /dev/null @@ -1,21 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.args.specific; - -import ru.fusionsoft.dbgit.integration.primitives.Credentials; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsDbGitAddRemote; -import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.GitTestRepoCredentials; - -public class GitTestRepoAddRemoteArgs extends ArgsDbGitAddRemote { - public GitTestRepoAddRemoteArgs(String url, String name, String user, String pass) { - super(url, name, user, pass); - } - public GitTestRepoAddRemoteArgs(String url, String name, Credentials credentials) { - this(url, name, credentials.username(), credentials.password()); - } - public GitTestRepoAddRemoteArgs(String name) { - this( - "https://github.com/rocket-3/dbgit-test.git", - name, - new GitTestRepoCredentials() - ); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfConsoleWhenRunning.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfConsoleWhenRunning.java new file mode 100644 index 0000000..6007204 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfConsoleWhenRunning.java @@ -0,0 +1,46 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.util.StringTokenizer; +import ru.fusionsoft.dbgit.integration.primitives.RunnableWithException; + +public class CharsOfConsoleWhenRunning extends CharsOf { + + public CharsOfConsoleWhenRunning(RunnableWithException runnable) { + super(() -> { + final PrintStream original = System.out; + try (final ByteArrayOutputStream cachedOutputStream = new ByteArrayOutputStream();) { + try { + + System.setOut(new PrintStream( + cachedOutputStream, + true, + "UTF-8" + )); + + runnable.run(); + return cachedOutputStream.toString(); + + } catch (Throwable e) { + throw new CharsOfConsoleWhenRunningException(cachedOutputStream, e); + } finally { + System.setOut(original); + } + } + }); + } + + public static class CharsOfConsoleWhenRunningException extends Error { + public CharsOfConsoleWhenRunningException(String text, Throwable cause) { + super( + text.isEmpty() ? "" : "Execution broken after:\n"+text, + text.isEmpty() ? cause : cause.getCause() + ); + } + + public CharsOfConsoleWhenRunningException(ByteArrayOutputStream byteArrayOutputStream, Throwable cause) { + this(byteArrayOutputStream.toString(), cause); + } + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfPathWithComment.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfPathWithComment.java new file mode 100644 index 0000000..4430ee9 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfPathWithComment.java @@ -0,0 +1,11 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.nio.file.Path; + +public class CharsOfPathWithComment extends CharsOf { + public CharsOfPathWithComment(Path origin, CharSequence comment) { + super(()->{ + return origin.toAbsolutePath().toString() + " # " + comment; + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsQuotedToRegexPattern.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsQuotedToRegexPattern.java new file mode 100644 index 0000000..1da53ac --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsQuotedToRegexPattern.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +public class CharsQuotedToRegexPattern extends CharSequenceEnvelope { + public CharsQuotedToRegexPattern(CharSequence origin) { + super(() -> { + return String.valueOf(origin).replaceAll("[\\W]", "\\\\$0"); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsWithMaskedCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsWithMaskedCredentials.java new file mode 100644 index 0000000..1032cec --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsWithMaskedCredentials.java @@ -0,0 +1,31 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.CredsOfGitTestRepo; +import ru.fusionsoft.dbgit.integration.primitives.credentials.specific.CredsOfPgTestDatabase; + +public class CharsWithMaskedCredentials extends CharSequenceEnvelope { + public CharsWithMaskedCredentials(CharSequence origin) { + super(() -> { + final List replacementsList = new ArrayList<>(); + try { + replacementsList.add(new CredsOfGitTestRepo().password()); + } catch (Throwable e) { } + try { + replacementsList.add(new CredsOfPgTestDatabase().password()); + } catch (Throwable e) { } + + return String + .valueOf(origin) + .replaceAll( + replacementsList + .stream() + .map(CharsQuotedToRegexPattern::new) + .collect(Collectors.joining("|")), + "****" + ); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CommitsFromRepo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CommitsFromRepo.java index 8099376..3dc0667 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CommitsFromRepo.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CommitsFromRepo.java @@ -10,10 +10,10 @@ import org.eclipse.jgit.transport.RefSpec; public class CommitsFromRepo { - private final String repoUrl; - private final String branchName; + private final CharSequence repoUrl; + private final CharSequence branchName; - public CommitsFromRepo(String repoUrl, String branchName) { + public CommitsFromRepo(CharSequence repoUrl, CharSequence branchName) { this.repoUrl = repoUrl; this.branchName = branchName; } @@ -28,11 +28,11 @@ public final List names() throws Exception { ) ) { git.fetch() - .setRemote(repoUrl) + .setRemote(String.valueOf(repoUrl)) .setRefSpecs( new RefSpec( "+refs/heads/" + branchName - + ":refs/heads/" + branchName + + ":refs/heads/" + branchName ) ) .call(); diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/InputStreamChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/InputStreamChars.java deleted file mode 100644 index 05d8d05..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/InputStreamChars.java +++ /dev/null @@ -1,41 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars; - -import java.io.BufferedReader; -import java.io.InputStream; -import java.io.InputStreamReader; - -public class InputStreamChars extends CharSequenceEnvelope{ - public InputStreamChars(InputStream origin, String codepageName) { - super(() -> { - - try ( - final BufferedReader reader = new BufferedReader( - codepageName.equals("default") - ? new InputStreamReader(origin) - : new InputStreamReader(origin, codepageName) - ) - ) { - StringBuilder builder = new StringBuilder(); - String line = null; - while (( line = reader.readLine() ) != null) { - builder.append("> "); - builder.append(line); - builder.append(System.getProperty("line.separator")); - } - return builder.toString(); - } - -// try (final Scanner s = new Scanner(origin)) { -// final StringBuilder text = new StringBuilder(); -// while (s.hasNextLine()) text -// .append("\n> ") -// .append(s.nextLine()); -// return text.toString(); -// } - }); - } - - public InputStreamChars(InputStream origin) { - this(origin, "default"); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java new file mode 100644 index 0000000..f3db956 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java @@ -0,0 +1,38 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.io.BufferedReader; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.List; +import java.util.stream.Collectors; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; +import ru.fusionsoft.dbgit.integration.primitives.StickyScalar; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.Lines; + +public class LinesFromInputStream implements Lines { + private final Scalar> listScalar; + public LinesFromInputStream(InputStream origin, String codepageName) { + this.listScalar = new StickyScalar<>( + () -> { + try ( + final BufferedReader reader = new BufferedReader( + codepageName.equals("default") + ? new InputStreamReader(origin) + : new InputStreamReader(origin, codepageName) + ) + ) { + return reader.lines().collect(Collectors.toList()); + } + } + ); + } + + public LinesFromInputStream(InputStream origin) { + this(origin, "default"); + } + + @Override + public final List list() throws Exception { + return listScalar.value(); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/SavedConsoleText.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/SavedConsoleText.java deleted file mode 100644 index 8d81410..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/SavedConsoleText.java +++ /dev/null @@ -1,69 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars; - -import java.io.ByteArrayOutputStream; -import java.io.OutputStream; -import java.io.PrintStream; -import java.util.Arrays; -import java.util.List; -import java.util.function.Consumer; -import ru.fusionsoft.dbgit.integration.primitives.RunnableWithException; - -public class SavedConsoleText { - private final RunnableWithException runnable; - - public SavedConsoleText(RunnableWithException runnable) { - this.runnable = runnable; - } - - public final String text() throws Exception{ - final PrintStream original = System.out; - try (final ByteArrayOutputStream cachedOutputStream = new ByteArrayOutputStream();) { - try { - - System.setOut(new PrintStream( - cachedOutputStream, - true, - "UTF-8" - )); - - runnable.run(); - return cachedOutputStream.toString(); - - } catch (RuntimeException e) { - final Throwable cause = e.getCause() != null ? e.getCause() : e; - throw new RuntimeException( - "Runtime exception occurred while catching this console output:\n" - + cachedOutputStream.toString(), - e - ); - } catch (Exception e) { - throw new Exception( - "Exception occurred while catching this console output:\n" - + cachedOutputStream.toString(), - e - ); - } catch (AssertionError e) { - final Throwable cause = e.getCause() != null ? e.getCause() : e; - throw new Error( - "Assertion failed while catching this console output:\n" - + cachedOutputStream.toString(), - e - ); - } catch (Error e) { - final Throwable cause = e.getCause() != null ? e.getCause() : e; - throw new Error( - "Error occurred while catching this console output:\n" - + cachedOutputStream.toString(), - e - ); - } finally { - System.setOut(original); - } - } - } - - public final List lines() throws Exception{ - return Arrays.asList(this.text().split("\\n")); - } - -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultDetailedChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultDetailedChars.java deleted file mode 100644 index 17fefcb..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultDetailedChars.java +++ /dev/null @@ -1,44 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars; - -import java.text.MessageFormat; -import java.util.concurrent.atomic.AtomicBoolean; -import org.junit.platform.commons.util.ExceptionUtils; -import ru.fusionsoft.dbgit.integration.primitives.Test; - -public class TestResultDetailedChars extends CharsOf { - - public TestResultDetailedChars(Subject subject, Test test) { - super( - () -> { - CharSequence details; - CharSequence successMarkChars; - - try { - final AtomicBoolean value = new AtomicBoolean(false); - details = new SavedConsoleText( - () -> { - value.set(test.value(subject)); - } - ).text(); - successMarkChars = new TestSuccessMarkChars(value.get()); - - } catch (Error e) { - details = ExceptionUtils.readStackTrace(e.getCause()); - successMarkChars = new TestSuccessMarkChars(e); - } catch (RuntimeException e) { - details = ExceptionUtils.readStackTrace(e.getCause()); - successMarkChars = new TestSuccessMarkChars(e); - } catch (Exception e) { - details = ExceptionUtils.readStackTrace(e.getCause()); - successMarkChars = new TestSuccessMarkChars(e); - } - return MessageFormat.format( - "{0} {1}\n{2}", - successMarkChars, - test.description(), - details - ); - } - ); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultShortChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultShortChars.java deleted file mode 100644 index ecfb21d..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestResultShortChars.java +++ /dev/null @@ -1,16 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars; - -import ru.fusionsoft.dbgit.integration.primitives.Test; - -public class TestResultShortChars extends CharsOf { - public TestResultShortChars(Subject subject, Test test) { - super( - () -> { - return String.valueOf( - new TestResultDetailedChars<>(subject, test) - ) - .split("\n")[0]; - } - ); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestSuccessMarkChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestSuccessMarkChars.java deleted file mode 100644 index 0492f5e..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/TestSuccessMarkChars.java +++ /dev/null @@ -1,21 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars; - -public class TestSuccessMarkChars extends CharSequenceEnvelope { - - public TestSuccessMarkChars(boolean booleanValue) { - super(()-> booleanValue ? "[TEST OK]" : "[TEST FAIL]"); - } - - public TestSuccessMarkChars(Exception testException) { - super(()-> "[TEST RUNNING EXCEPTION]"); - } - - public TestSuccessMarkChars(Error subjectConstructionError ) { - super(() -> "[TEST SUBJECT ERROR]"); - } - - public TestSuccessMarkChars(RuntimeException subjectConstructionRuntimeException ) { - super(() -> "[TEST SUBJECT ERROR]"); - } - -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/NameOfDefaultTargetTestDatabase.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/NameOfDefaultTargetTestDatabase.java new file mode 100644 index 0000000..c21de49 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/NameOfDefaultTargetTestDatabase.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific; + +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public class NameOfDefaultTargetTestDatabase extends CharSequenceEnvelope { + public NameOfDefaultTargetTestDatabase() { + super(()->"test#databasegit"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/UrlOfGitTestRepo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/UrlOfGitTestRepo.java new file mode 100644 index 0000000..fccf497 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/UrlOfGitTestRepo.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific; + +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public class UrlOfGitTestRepo extends CharSequenceEnvelope { + public UrlOfGitTestRepo() { + super(()-> "https://github.com/rocket-3/dbgit-test.git"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbIgnoreDefaultChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreDefault.java similarity index 63% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbIgnoreDefaultChars.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreDefault.java index 68ebfe7..018fe9f 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbIgnoreDefaultChars.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreDefault.java @@ -1,8 +1,10 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars; +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit; -public class DbIgnoreDefaultChars extends CharSequenceEnvelope { +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; - public DbIgnoreDefaultChars() { +public class CharsDbIgnoreDefault extends CharSequenceEnvelope { + + public CharsDbIgnoreDefault() { super(() -> { return "*\n" + diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreWithTableData.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreWithTableData.java new file mode 100644 index 0000000..1084bfe --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreWithTableData.java @@ -0,0 +1,23 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit; + +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public class CharsDbIgnoreWithTableData extends CharSequenceEnvelope { + public CharsDbIgnoreWithTableData() { + super(() -> { + return + "*\n" + + "!public/*.ts\n" + + "!public/*.sch\n" + + "!public/*.seq\n" + + "!public/*.tbl\n" + + "!public/*.pkg\n" + + "!public/*.trg\n" + + "!public/*.prc\n" + + "!public/*.fnc\n" + + "!public/*.vw\n" + + "!public/*.blob\n" + + "!public/*.csv\n"; + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbLinkChars.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbLink.java similarity index 64% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbLinkChars.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbLink.java index 954de4b..5d30711 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/DbLinkChars.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbLink.java @@ -1,10 +1,11 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars; +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit; import java.text.MessageFormat; import ru.fusionsoft.dbgit.integration.primitives.Credentials; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; -public class DbLinkChars extends CharSequenceEnvelope { - public DbLinkChars(String url, String catalog, Credentials credentials) { +public class CharsDbLink extends CharSequenceEnvelope { + public CharsDbLink(String url, String catalog, Credentials credentials) { super(() -> { return MessageFormat.format( diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/CharsOfLines.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/CharsOfLines.java new file mode 100644 index 0000000..17a56e7 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/CharsOfLines.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; +import java.util.List; +import java.util.stream.Collectors; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public class CharsOfLines extends CharSequenceEnvelope { + public CharsOfLines(Lines lines, CharSequence linePrefix) { + super(() -> { + return lines.list().stream().map(x -> linePrefix + x).collect(Collectors.joining("\n")); + }); + } + public CharsOfLines(List list, CharSequence linePrefix) { + super(() -> { + return list.stream().map(x -> linePrefix + x).collect(Collectors.joining("\n")); + }); + } + + public CharsOfLines(Lines lines) { + this(lines, ""); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRun.java new file mode 100644 index 0000000..9925411 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRun.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +import java.text.MessageFormat; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public abstract class LabelOfTestRun extends CharSequenceEnvelope { + public LabelOfTestRun(CharSequence text) { + super(()-> MessageFormat.format("[{0}]", text)); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunBrokenSubject.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunBrokenSubject.java new file mode 100644 index 0000000..38dff25 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunBrokenSubject.java @@ -0,0 +1,7 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +public class LabelOfTestRunBrokenSubject extends LabelOfTestRun { + public LabelOfTestRunBrokenSubject() { + super("SUBJECT ACCESS ERROR"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunExceptional.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunExceptional.java new file mode 100644 index 0000000..5baf441 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunExceptional.java @@ -0,0 +1,7 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +public class LabelOfTestRunExceptional extends LabelOfTestRun { + public LabelOfTestRunExceptional() { + super("TEST FAIL EXCEPTION"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunResult.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunResult.java new file mode 100644 index 0000000..600eb54 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LabelOfTestRunResult.java @@ -0,0 +1,7 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +public class LabelOfTestRunResult extends LabelOfTestRun { + public LabelOfTestRunResult(boolean checkResult) { + super(checkResult ? "TEST OK" : "TEST FAIL"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/Lines.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/Lines.java new file mode 100644 index 0000000..de102f4 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/Lines.java @@ -0,0 +1,7 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +import java.util.List; + +public interface Lines { + List list() throws Exception; +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOf.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOf.java new file mode 100644 index 0000000..3e0d18b --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOf.java @@ -0,0 +1,18 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +import java.util.Arrays; +import java.util.List; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; + +public class LinesOf implements Lines { + private final Scalar stringScalar; + + public LinesOf(CharSequence charSequence) { + this.stringScalar = charSequence::toString; + } + + @Override + public final List list() throws Exception { + return Arrays.asList(stringScalar.value().split("\n")); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOfString.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOfString.java new file mode 100644 index 0000000..0b2d398 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOfString.java @@ -0,0 +1,17 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +import java.util.Arrays; +import java.util.List; + +public class LinesOfString implements Lines { + private final String string; + + public LinesOfString(String string) { + this.string = string; + } + + @Override + public final List list() { + return Arrays.asList(string.split("\n")); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestFormat.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestFormat.java new file mode 100644 index 0000000..cac00a0 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestFormat.java @@ -0,0 +1,33 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +import java.text.MessageFormat; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public class ReportOfTestFormat extends CharSequenceEnvelope { + public ReportOfTestFormat(LabelOfTestRun label, CharSequence description, CharSequence subjectDetails, CharSequence testDetails) { + super(() -> { + final CharSequence subjectPart = String.valueOf(subjectDetails).trim().isEmpty() + ? "" + : "\n" + new CharsOfLines(new LinesOf(subjectDetails), "| "); + final CharSequence testPart = String.valueOf(testDetails).trim().isEmpty() + ? "" + : "\n" + new CharsOfLines(new LinesOf(testDetails), "| "); + + return MessageFormat.format( + "{0} \"{1}\"{2}{3}" + , label + , description + , subjectPart + , testPart + ); + }); + } + + public ReportOfTestFormat(LabelOfTestRun label, CharSequence description, CharSequence details) { + this(label, description, details, ""); + } + + public ReportOfTestFormat(LabelOfTestRun label, CharSequence description) { + this(label, description, ""); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestGroupRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestGroupRun.java new file mode 100644 index 0000000..8463747 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestGroupRun.java @@ -0,0 +1,45 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import org.junit.platform.commons.util.ExceptionUtils; +import ru.fusionsoft.dbgit.integration.primitives.SimpleTestResult; +import ru.fusionsoft.dbgit.integration.primitives.Test; +import ru.fusionsoft.dbgit.integration.primitives.TestResult; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfConsoleWhenRunning; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsWithMaskedCredentials; + +public class ReportOfTestGroupRun extends CharSequenceEnvelope { + @SafeVarargs + public ReportOfTestGroupRun(CharSequence description, Subj subject, Test... tests) { + super(() -> { + return new CharsWithMaskedCredentials(new CharsOf(() -> { + try { + final String subjectConsoleOutput = String.valueOf(new CharsOfConsoleWhenRunning(subject::toString)); + + final List testResults = Arrays + .stream(tests) + .map(x -> new SimpleTestResult<>(subject, x)) + .collect(Collectors.toList()); + + return new ReportOfTestFormat( + new LabelOfTestRunResult(testResults.stream().allMatch(TestResult::value)), + description, + new CharsOfLines(new LinesOf(subjectConsoleOutput), ""), + new CharsOfLines(testResults.stream().map(TestResult::text).collect(Collectors.toList()), "") + ); + } catch (CharsOfConsoleWhenRunning.CharsOfConsoleWhenRunningException e) { + return new ReportOfTestFormat( + new LabelOfTestRunBrokenSubject(), + description, + "Thrown: " + ExceptionUtils.readStackTrace(e) + ); + } + + })); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestRun.java new file mode 100644 index 0000000..abef103 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestRun.java @@ -0,0 +1,48 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; + +import java.util.concurrent.atomic.AtomicBoolean; +import org.junit.platform.commons.util.ExceptionUtils; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalar; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalarOf; +import ru.fusionsoft.dbgit.integration.primitives.Test; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfConsoleWhenRunning; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsWithMaskedCredentials; + +public class ReportOfTestRun extends CharSequenceEnvelope { + public ReportOfTestRun(Subj subject, Test test) { + super(() -> { + return new CharsWithMaskedCredentials(new CharsOf(() -> { + try { + final CharSequence subjDetails = String.valueOf(new CharsOfConsoleWhenRunning(subject::toString)); + try { + final AtomicBoolean value = new AtomicBoolean(false); + final CharSequence testDetails = String.valueOf(new CharsOfConsoleWhenRunning(()-> value.set(test.value(subject)))); + final LabelOfTestRun label = new LabelOfTestRunResult(value.get()); + return new ReportOfTestFormat(label, test.description(), subjDetails, testDetails); + + } catch (SafeScalarOf.SafeScalarError subjectThrowable) { + return new ReportOfTestFormat( + new LabelOfTestRunBrokenSubject() + , test.description() + , ExceptionUtils.readStackTrace(subjectThrowable.getCause()) + ); + } catch (Throwable testThrowable) { + return new ReportOfTestFormat( + new LabelOfTestRunExceptional() + , test.description() + , ExceptionUtils.readStackTrace(testThrowable) + ); + } + } catch (CharsOfConsoleWhenRunning.CharsOfConsoleWhenRunningException subjectThrowable) { + return new ReportOfTestFormat( + new LabelOfTestRunBrokenSubject() + , test.description() + , ExceptionUtils.readStackTrace(subjectThrowable) + ); + } + })); + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromFileCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsFromFile.java similarity index 57% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromFileCredentials.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsFromFile.java index 9f34c09..8c30ded 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromFileCredentials.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsFromFile.java @@ -3,14 +3,17 @@ import java.nio.file.Path; import ru.fusionsoft.dbgit.integration.primitives.files.FileContent; -public class FromFileCredentials extends CredentialsEnvelope { +public class CredentialsFromFile extends CredentialsEnvelope { - public FromFileCredentials(Path secretFilePath) { + public CredentialsFromFile(Path secretFilePath) { super(()-> { final String[] lines = new FileContent(secretFilePath) .text() .split("\n"); - return new SimpleCredentials(lines[0],lines[1]); + return new SimpleCredentials( + lines[0].trim(), + lines[1].trim() + ); }); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromPropertiesCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsFromProperties.java similarity index 80% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromPropertiesCredentials.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsFromProperties.java index 3521a2b..077be9b 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/FromPropertiesCredentials.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/CredentialsFromProperties.java @@ -1,7 +1,7 @@ package ru.fusionsoft.dbgit.integration.primitives.credentials; -public class FromPropertiesCredentials extends CredentialsEnvelope { - public FromPropertiesCredentials(String usrPropName, String pwdPropName) { +public class CredentialsFromProperties extends CredentialsEnvelope { + public CredentialsFromProperties(String usrPropName, String pwdPropName) { super(()-> { final String usrValue = System.getProperty(usrPropName); final String pwdValue = System.getProperty(pwdPropName); diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromGitMvnDProps.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromGitMvnDProps.java new file mode 100644 index 0000000..98ac81c --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromGitMvnDProps.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; + +import ru.fusionsoft.dbgit.integration.primitives.credentials.CredentialsFromProperties; + +public class CredsFromGitMvnDProps extends CredentialsFromProperties { + public CredsFromGitMvnDProps() { + super("gitUser", "gitPass"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoFileCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromGitSecretFile.java similarity index 55% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoFileCredentials.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromGitSecretFile.java index c637e39..a265b83 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoFileCredentials.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromGitSecretFile.java @@ -1,10 +1,10 @@ package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; -import ru.fusionsoft.dbgit.integration.primitives.credentials.FromFileCredentials; +import ru.fusionsoft.dbgit.integration.primitives.credentials.CredentialsFromFile; import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; -public class GitTestRepoFileCredentials extends FromFileCredentials { - public GitTestRepoFileCredentials() { +public class CredsFromGitSecretFile extends CredentialsFromFile { + public CredsFromGitSecretFile() { super(new CurrentWorkingDirectory().resolve("../gitSecret.txt")); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromPgMvnDProps.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromPgMvnDProps.java new file mode 100644 index 0000000..389ae9a --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromPgMvnDProps.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; + +import ru.fusionsoft.dbgit.integration.primitives.credentials.CredentialsFromProperties; + +public class CredsFromPgMvnDProps extends CredentialsFromProperties { + public CredsFromPgMvnDProps() { + super("pgUser", "pgPass"); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgFileCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromPgSecretFile.java similarity index 56% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgFileCredentials.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromPgSecretFile.java index b8b4973..51ba303 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgFileCredentials.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsFromPgSecretFile.java @@ -1,10 +1,10 @@ package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; -import ru.fusionsoft.dbgit.integration.primitives.credentials.FromFileCredentials; +import ru.fusionsoft.dbgit.integration.primitives.credentials.CredentialsFromFile; import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; -public class PgFileCredentials extends FromFileCredentials { - public PgFileCredentials() { +public class CredsFromPgSecretFile extends CredentialsFromFile { + public CredsFromPgSecretFile() { super(new CurrentWorkingDirectory().resolve("../pgSecret.txt")); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsOfGitTestRepo.java similarity index 74% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgCredentials.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsOfGitTestRepo.java index cdf4d0e..c81dc57 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgCredentials.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsOfGitTestRepo.java @@ -4,17 +4,17 @@ import ru.fusionsoft.dbgit.integration.primitives.credentials.CredentialsEnvelope; import ru.fusionsoft.dbgit.integration.primitives.credentials.SimpleCredentials; -public class PgCredentials extends CredentialsEnvelope { - public PgCredentials() { +public class CredsOfGitTestRepo extends CredentialsEnvelope { + public CredsOfGitTestRepo() { super(() -> { try { - final Credentials creds = new PgPropsCredentials(); + final Credentials creds = new CredsFromGitMvnDProps(); return new SimpleCredentials( creds.username(), creds.password() ); } catch (Throwable e) { - final Credentials creds = new PgFileCredentials(); + final Credentials creds = new CredsFromGitSecretFile(); return new SimpleCredentials( creds.username(), creds.password() diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsOfPgTestDatabase.java similarity index 72% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoCredentials.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsOfPgTestDatabase.java index a0885b4..334b1ac 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoCredentials.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/CredsOfPgTestDatabase.java @@ -4,17 +4,17 @@ import ru.fusionsoft.dbgit.integration.primitives.credentials.CredentialsEnvelope; import ru.fusionsoft.dbgit.integration.primitives.credentials.SimpleCredentials; -public class GitTestRepoCredentials extends CredentialsEnvelope { - public GitTestRepoCredentials() { +public class CredsOfPgTestDatabase extends CredentialsEnvelope { + public CredsOfPgTestDatabase() { super(() -> { try { - final Credentials creds = new GitTestRepoPropsCredentials(); + final Credentials creds = new CredsFromPgMvnDProps(); return new SimpleCredentials( creds.username(), creds.password() ); } catch (Throwable e) { - final Credentials creds = new GitTestRepoFileCredentials(); + final Credentials creds = new CredsFromPgSecretFile(); return new SimpleCredentials( creds.username(), creds.password() diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoPropsCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoPropsCredentials.java deleted file mode 100644 index 97ebb4b..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/GitTestRepoPropsCredentials.java +++ /dev/null @@ -1,9 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; - -import ru.fusionsoft.dbgit.integration.primitives.credentials.FromPropertiesCredentials; - -public class GitTestRepoPropsCredentials extends FromPropertiesCredentials { - public GitTestRepoPropsCredentials() { - super("gitUser", "gitPass"); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgPropsCredentials.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgPropsCredentials.java deleted file mode 100644 index 26b1501..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/credentials/specific/PgPropsCredentials.java +++ /dev/null @@ -1,9 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.credentials.specific; - -import ru.fusionsoft.dbgit.integration.primitives.credentials.FromPropertiesCredentials; - -public class PgPropsCredentials extends FromPropertiesCredentials { - public PgPropsCredentials() { - super("pgUser", "pgPass"); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchAssertsNotMvnProjectRoot.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchAssertsNotMvnProjectRoot.java new file mode 100644 index 0000000..f351279 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchAssertsNotMvnProjectRoot.java @@ -0,0 +1,26 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Patch; + +public class PathPatchAssertsNotMvnProjectRoot implements Patch { + @Override + public final void apply(Path root) throws Exception { + if ( + root.resolve(".git").toFile().exists() && + root.resolve("pom.xml").toFile().exists() + ) { + throw new PathIsProjectRootException(root); + } + } + + private static class PathIsProjectRootException extends RuntimeException { + PathIsProjectRootException(Path path) { + super( + "\nGiven path " + path.toString() + " " + + "points to a project root directory.\n" + + "I'm here not to allow that." + ); + } + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCloningGitRepo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCloningGitRepo.java index b2f4673..a58c5f9 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCloningGitRepo.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCloningGitRepo.java @@ -2,30 +2,26 @@ import java.io.PrintStream; import java.nio.file.Path; -import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; -import ru.fusionsoft.dbgit.integration.primitives.PatchSequental; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; -public class PathPatchCloningGitRepo extends PatchSequental { +public class PathPatchCloningGitRepo extends PatchSequential { public PathPatchCloningGitRepo(final String repoUrl, final String branchName, PrintStream printStream) { super( - new PathPatchRunningProcessFrom( + new PathPatchRunningExecutable( + "git", new ArgsExplicit( - System.getenv("ComSpec"), - "/C", - "git", "clone", repoUrl, "." ), printStream ), - new PathPatchRunningProcessFrom( + new PathPatchRunningExecutable( + "git", new ArgsExplicit( - System.getenv("ComSpec"), - "/C", - "git", "reset", "--hard", branchName @@ -37,6 +33,6 @@ public PathPatchCloningGitRepo(final String repoUrl, final String branchName, Pr } public PathPatchCloningGitRepo(final String repoUrl, final String branchName) { - this(repoUrl, branchName, new NullPrintStream()); + this(repoUrl, branchName, new DefaultPrintStream()); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchConfiguringDbGit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchConfiguringDbGit.java index 9405721..9979cc3 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchConfiguringDbGit.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchConfiguringDbGit.java @@ -1,9 +1,9 @@ package ru.fusionsoft.dbgit.integration.primitives.patch; import java.nio.file.Path; -import ru.fusionsoft.dbgit.integration.primitives.PatchSequental; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; -public class PathPatchConfiguringDbGit extends PatchSequental { +public class PathPatchConfiguringDbGit extends PatchSequential { public PathPatchConfiguringDbGit(final String linkContent, final String ignoreContent, final String configContent, final String indexContent) { super( diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCreatingFile.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCreatingFile.java index a7ba0a8..f77e472 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCreatingFile.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchCreatingFile.java @@ -1,21 +1,39 @@ package ru.fusionsoft.dbgit.integration.primitives.patch; import java.io.File; +import java.io.PrintStream; import java.nio.file.Path; +import java.util.Arrays; +import java.util.stream.Collectors; import org.apache.commons.io.FileUtils; -import ru.fusionsoft.dbgit.integration.primitives.Patch; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfPathWithComment; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; -public class PathPatchCreatingFile implements Patch { +public class PathPatchCreatingFile extends PathPatchWithPrintStream { private final String name; private final String content; - public PathPatchCreatingFile(final String name, final CharSequence content) { + public PathPatchCreatingFile(final String name, final CharSequence content, PrintStream printStream) { + super(printStream); this.name = name; this.content = String.valueOf(content); } + public PathPatchCreatingFile(final String name, final CharSequence content) { + this(name, content, new DefaultPrintStream()); + } + @Override public final void apply(final Path root) throws Exception { + this.printStream.println( + new CharsOfPathWithComment( + root, + "writing file " + name + " with content:\n" + + Arrays.stream(content.split("\n")) + .map( x-> "> " + x) + .collect(Collectors.joining(System.getProperty("line.separator"))) + ) + ); final File file = root.resolve(this.name).toFile(); file.getParentFile().mkdirs(); FileUtils.writeStringToFile(file, this.content); diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGitFrom.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGit.java similarity index 54% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGitFrom.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGit.java index cfdd872..50a0a90 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGitFrom.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningDbGit.java @@ -5,11 +5,12 @@ import ru.fusionsoft.dbgit.integration.primitives.Args; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsRunningCommand; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithAppend; -import ru.fusionsoft.dbgit.integration.primitives.path.PathOfBuiltDbGitExecutable; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.PathOfBuiltDbGitExecutable; import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; -public class PathPatchRunningDbGitFrom extends PathPatchRunningProcessFrom { - public PathPatchRunningDbGitFrom(Args args, Path executablePath, PrintStream printStream) { +public class PathPatchRunningDbGit extends PathPatchRunningProcessFrom { + public PathPatchRunningDbGit(Args args, Path executablePath, PrintStream printStream) { super( new ArgsWithAppend( new ArgsRunningCommand(executablePath), @@ -19,28 +20,23 @@ public PathPatchRunningDbGitFrom(Args args, Path executablePath, PrintStream pri ); } - public PathPatchRunningDbGitFrom(Args args, Path executablePath) { + public PathPatchRunningDbGit(Args args, Path executablePath) { this( - args, - executablePath, + args, + executablePath, System.out ); } - - public PathPatchRunningDbGitFrom(Args args, PrintStream printStream) { + + public PathPatchRunningDbGit(Args args, PrintStream printStream) { this( - args, - new PathOfBuiltDbGitExecutable(new CurrentWorkingDirectory()), + args, + new PathOfBuiltDbGitExecutable(new CurrentWorkingDirectory()), printStream ); } - public PathPatchRunningDbGitFrom(Args args) { - this( - args, - System.out - ); + public PathPatchRunningDbGit(Args args) { + this(args, new DefaultPrintStream()); } - - } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningExecutable.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningExecutable.java new file mode 100644 index 0000000..9a38764 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningExecutable.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsRunningCommand; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithAppend; + +public class PathPatchRunningExecutable extends PathPatchRunningProcessFrom { + + public PathPatchRunningExecutable(CharSequence commandName, Args commandArgs, PrintStream printStream) { + super( + new ArgsWithAppend( + new ArgsRunningCommand(commandName), + commandArgs + ), + printStream + ); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningGit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningGit.java new file mode 100644 index 0000000..c64f90e --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningGit.java @@ -0,0 +1,25 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.PrintStream; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; + +public class PathPatchRunningGit extends PathPatchRunningExecutable { + public PathPatchRunningGit(Args gitArgs, PrintStream printStream) { + super( + "git", + gitArgs, + printStream + ); + } + + public PathPatchRunningGit(Args gitArgs) { + this(gitArgs, new DefaultPrintStream()); + } + + public PathPatchRunningGit(CharSequence... gitArgs) { + this(new ArgsExplicit(gitArgs)); + } +} + diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java index c1da387..9d0ae70 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java @@ -9,7 +9,8 @@ import java.util.stream.Collectors; import ru.fusionsoft.dbgit.integration.primitives.Args; import ru.fusionsoft.dbgit.integration.primitives.Patch; -import ru.fusionsoft.dbgit.integration.primitives.chars.InputStreamChars; +import ru.fusionsoft.dbgit.integration.primitives.chars.LinesFromInputStream; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.CharsOfLines; public class PathPatchRunningProcessFrom implements Patch { @@ -21,11 +22,6 @@ public PathPatchRunningProcessFrom(Args processRunCommandLine, PrintStream print this.printStream = printStream; } -// public PathPatchRunningProcessFrom(Args processRunCommandLine) { -// this.processRunCommandLine = processRunCommandLine; -// this.printStream = System.out; -// } - @Override public final void apply(Path root) throws Exception { try ( @@ -36,31 +32,37 @@ public final void apply(Path root) throws Exception { "UTF-8" ) ) { + final Consumer outputConsumer = (chars) -> { cachedPrintStream.println(chars); printStream.println(chars); }; - + outputConsumer.accept(MessageFormat.format( "{0} # {1}", root.toString(), - String.join(" ", processRunCommandLine.values()) + String.join( + " ", + processRunCommandLine.values() + ) )); final Process process = new ProcessBuilder() - .directory(root.toAbsolutePath().toFile()) - .command( - Arrays.stream(processRunCommandLine.values()) - .map(String::valueOf) - .collect(Collectors.toList()) - ) - .start(); + .directory(root.toAbsolutePath().toFile()) + .command( + Arrays.stream(processRunCommandLine.values()) + .map(String::valueOf) + .collect(Collectors.toList()) + ) + .start(); - final CharSequence processOutput = String.valueOf(new InputStreamChars( - process.getInputStream() - )); - final CharSequence processErrOutput = new InputStreamChars( - process.getErrorStream(), "Cp866" + final CharSequence processOutput = String.valueOf( + new CharsOfLines( + new LinesFromInputStream(process.getInputStream()), "> " + ) + ); + final CharSequence processErrOutput = new CharsOfLines( + new LinesFromInputStream(process.getErrorStream(), "Utf-8"), "> " ); final int exitCode = process.waitFor(); @@ -68,17 +70,17 @@ public final void apply(Path root) throws Exception { outputConsumer.accept(processOutput); if (exitCode != 0) { - throw new RuntimeException(MessageFormat.format( - "Process exited with error, code {0}" - + "\nErrors: {1}" - + "\nOriginal output: {2}" - ,exitCode - ,processErrOutput.length() != 0 - ? "\n" + processErrOutput + throw new Exception(MessageFormat.format( + "Process exited with error, code {0}" + + "\nErrors: {1}" +// + "\nOriginal output: {2}" + , exitCode + , processErrOutput.length() != 0 + ? "\n" + processErrOutput : "...error stream was empty" - ,cachedOutputStream.size() != 0 - ? "\n" + cachedOutputStream.toString() - : "...output stream was empty" +// ,cachedOutputStream.size() != 0 +// ? "\n" + cachedOutputStream.toString() +// : "...output stream was empty" )); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchWithPrintStream.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchWithPrintStream.java new file mode 100644 index 0000000..12d4586 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchWithPrintStream.java @@ -0,0 +1,13 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Patch; + +public abstract class PathPatchWithPrintStream implements Patch { + protected final PrintStream printStream; + + public PathPatchWithPrintStream(PrintStream printStream) { + this.printStream = printStream; + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitAdd.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitAdd.java new file mode 100644 index 0000000..b4ac2cd --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitAdd.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAdd; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; + +public class PathPatchDbGitAdd extends PathPatchRunningDbGit { + public PathPatchDbGitAdd(CharSequence mask, PrintStream printStream) { + super(new ArgsDbGitAdd(mask), printStream); + } + public PathPatchDbGitAdd(PrintStream printStream) { + super(new ArgsDbGitAdd(), printStream); + } + public PathPatchDbGitAdd(CharSequence mask) { + this(mask, new DefaultPrintStream()); + } + public PathPatchDbGitAdd() { + this(new DefaultPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckout.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckout.java new file mode 100644 index 0000000..6e76963 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckout.java @@ -0,0 +1,18 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitCheckout; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; + +public class PathPatchDbGitCheckout extends PathPatchRunningDbGit { + public PathPatchDbGitCheckout(ArgsDbGitCheckout args, PrintStream printStream) { + super(args, printStream); + } + public PathPatchDbGitCheckout(ArgsDbGitCheckout args) { + this(args, new DefaultPrintStream()); + } + public PathPatchDbGitCheckout(CharSequence... args) { + this(new ArgsDbGitCheckout(args)); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckoutReset.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckoutReset.java new file mode 100644 index 0000000..ad63502 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckoutReset.java @@ -0,0 +1,25 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitCheckout; + +public class PathPatchDbGitCheckoutReset extends PatchSequential { + public PathPatchDbGitCheckoutReset(ArgsDbGitCheckout checkoutArgs, PrintStream printStream) { + super( + new PathPatchDbGitCheckout(checkoutArgs, printStream), + new PathPatchDbGitReset("-hard") + ); + } + + public PathPatchDbGitCheckoutReset(ArgsDbGitCheckout checkoutArgs) { + this(checkoutArgs, new DefaultPrintStream()); + } + + public PathPatchDbGitCheckoutReset(CharSequence... checkoutParams) { + this(new ArgsDbGitCheckout(checkoutParams)); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitClonesRepo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitClonesRepo.java new file mode 100644 index 0000000..776872f --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitClonesRepo.java @@ -0,0 +1,41 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemote; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitClone; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchAssertsNotMvnProjectRoot; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFilesWildcard; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; + +public class PathPatchDbGitClonesRepo extends PatchSequential { + public PathPatchDbGitClonesRepo(CharSequence repoUrl, ArgsDbGitAddRemote addRemoteArgs, PrintStream printStream) { + super( + new PathPatchAssertsNotMvnProjectRoot(), + new PathPatchDeletingFilesWildcard( + "*" + ), + new PathPatchRunningDbGit( + new ArgsDbGitClone(repoUrl), + printStream + ), + new PathPatchRunningDbGit( + addRemoteArgs, + printStream + ) + ); + } + public PathPatchDbGitClonesRepo(CharSequence repoUrl, PrintStream printStream) { + super( + new PathPatchRunningDbGit( + new ArgsDbGitClone(repoUrl), + printStream + ) + ); + } + public PathPatchDbGitClonesRepo(CharSequence repoUrl, ArgsDbGitAddRemote addRemoteArgs) { + this(repoUrl, addRemoteArgs, new DefaultPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCommit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCommit.java new file mode 100644 index 0000000..008a4b6 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCommit.java @@ -0,0 +1,16 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; + +public class PathPatchDbGitCommit extends PathPatchRunningDbGit { + public PathPatchDbGitCommit(CharSequence message, PrintStream printStream) { + super(new ArgsExplicit("commit", "-m", message), printStream); + } + + public PathPatchDbGitCommit(CharSequence message) { + this(message, new DefaultPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitInitializesRepo.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitInitializesRepo.java new file mode 100644 index 0000000..8df7145 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitInitializesRepo.java @@ -0,0 +1,38 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitInit; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLink; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchAssertsNotMvnProjectRoot; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFilesWildcard; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; + +public class PathPatchDbGitInitializesRepo extends PatchSequential { + public PathPatchDbGitInitializesRepo(ArgsDbGitLink linkArgs, PrintStream printStream) { + super( + new PathPatchAssertsNotMvnProjectRoot(), + new PathPatchDeletingFilesWildcard("*"), + new PathPatchRunningDbGit(new ArgsDbGitInit(), printStream), + new PathPatchRunningDbGit(linkArgs, printStream) + ); + } + + public PathPatchDbGitInitializesRepo(PrintStream printStream) { + super( + new PathPatchAssertsNotMvnProjectRoot(), + new PathPatchDeletingFilesWildcard("*"), + new PathPatchRunningDbGit(new ArgsDbGitInit(), printStream) + ); + } + + public PathPatchDbGitInitializesRepo(ArgsDbGitLink linkArgs) { + this(linkArgs, new DefaultPrintStream()); + } + + public PathPatchDbGitInitializesRepo() { + this(new DefaultPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitLink.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitLink.java new file mode 100644 index 0000000..4b44990 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitLink.java @@ -0,0 +1,17 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLink; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; + +public class PathPatchDbGitLink extends PathPatchRunningDbGit { + + public PathPatchDbGitLink(ArgsDbGitLink args, PrintStream printStream) { + super(args, printStream); + } + + public PathPatchDbGitLink(ArgsDbGitLink args) { + this(args, new DefaultPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitReset.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitReset.java new file mode 100644 index 0000000..1faf9f6 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitReset.java @@ -0,0 +1,20 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitReset; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; + +public class PathPatchDbGitReset extends PathPatchRunningDbGit { + public PathPatchDbGitReset(CharSequence resetMode, PrintStream printStream) { + super(new ArgsDbGitReset(resetMode), printStream); + } + + public PathPatchDbGitReset(CharSequence resetMode) { + this(resetMode, new DefaultPrintStream()); + } + + public PathPatchDbGitReset() { + this("hard", new DefaultPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitRestore.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitRestore.java new file mode 100644 index 0000000..b750867 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitRestore.java @@ -0,0 +1,20 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitRestore; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; + +public class PathPatchDbGitRestore extends PathPatchRunningDbGit { + public PathPatchDbGitRestore(ArgsDbGitRestore restoreArgs, PrintStream printStream) { + super(restoreArgs, printStream); + } + + public PathPatchDbGitRestore(ArgsDbGitRestore restoreArgs) { + this(restoreArgs, new DefaultPrintStream()); + } + + public PathPatchDbGitRestore(CharSequence... restoreCommandArgs) { + this(new ArgsDbGitRestore(restoreCommandArgs), new DefaultPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchGitCheckoutOrphan.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchGitCheckoutOrphan.java new file mode 100644 index 0000000..1301792 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchGitCheckoutOrphan.java @@ -0,0 +1,27 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningGit; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; + +public class PathPatchGitCheckoutOrphan extends PatchSequential { + public PathPatchGitCheckoutOrphan(String newBranchName, PrintStream printStream) { + super( + new PathPatchRunningGit( + new ArgsExplicit("checkout", "--orphan", newBranchName), + printStream + ), + new PathPatchRunningGit( + new ArgsExplicit("rm", "-rf", "."), + printStream + ) + ); + } + + public PathPatchGitCheckoutOrphan(String newBranchName) { + this(newBranchName, new DefaultPrintStream()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRestore.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRestore.java deleted file mode 100644 index 408f642..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRestore.java +++ /dev/null @@ -1,42 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.path; - -import java.io.PrintStream; -import java.nio.file.Path; -import ru.fusionsoft.dbgit.integration.primitives.Args; -import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsCheckoutNodb; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; -import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; - -public class PathAfterDbGitRestore extends PathAfterDbGitRun { - - public PathAfterDbGitRestore(ArgsCheckoutNodb checkoutArgs, ArgsLink linkArgs, Path dbGitExecutablePath, PrintStream printStream, Path dbGitRepo) { - super( - new ArgsExplicit("restore", "-r"), - dbGitExecutablePath, - printStream, - new PathWithDbGitCheckoutAndLink( - checkoutArgs, - linkArgs, - printStream, - dbGitRepo - ) - ); - } - - public PathAfterDbGitRestore(ArgsCheckoutNodb checkoutArgs, ArgsLink linkArgs, Path dbGitExecutablePath, Path dbGitRepo) { - this(checkoutArgs, linkArgs, dbGitExecutablePath, new NullPrintStream(), dbGitRepo); - } - - - public PathAfterDbGitRestore(ArgsCheckoutNodb checkoutArgs, ArgsLink linkArgs, Path dbGitRepo) { - this( - checkoutArgs, - linkArgs, - new CurrentWorkingDirectory(), - dbGitRepo - ); - } - -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRun.java index 63d5dfe..7597278 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRun.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterDbGitRun.java @@ -3,16 +3,17 @@ import java.io.PrintStream; import java.nio.file.Path; import ru.fusionsoft.dbgit.integration.primitives.Args; -import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.PathOfBuiltDbGitExecutable; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsRunningCommand; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithAppend; import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; -public class PathAfterDbGitRun extends PathAfterCommandRun { +public class PathAfterDbGitRun extends PathAfterProcessRun { public PathAfterDbGitRun(Args args, Path executablePath, PrintStream printStream, Path workingDirectory) { super( new ArgsWithAppend( - new ArgsRunningCommand(executablePath, workingDirectory), + new ArgsRunningCommand(executablePath), args ), printStream, @@ -33,7 +34,7 @@ public PathAfterDbGitRun(Args args, Path executablePath, Path workingDirectory) this( args, executablePath, - new NullPrintStream(), + new DefaultPrintStream(), workingDirectory ); } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterGitRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterGitRun.java new file mode 100644 index 0000000..b396a77 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterGitRun.java @@ -0,0 +1,21 @@ +package ru.fusionsoft.dbgit.integration.primitives.path; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsRunningCommand; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithAppend; + +public class PathAfterGitRun extends PathAfterProcessRun { + public PathAfterGitRun(Args gitArgs, PrintStream printStream, Path origin) { + super( + new ArgsWithAppend(new ArgsRunningCommand("git"), gitArgs), + printStream, + origin + ); + } + public PathAfterGitRun(Args gitArgs, Path origin) { + this(gitArgs, new DefaultPrintStream(), origin); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterCommandRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterProcessRun.java similarity index 53% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterCommandRun.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterProcessRun.java index f409fa8..8ff963f 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterCommandRun.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathAfterProcessRun.java @@ -1,21 +1,12 @@ package ru.fusionsoft.dbgit.integration.primitives.path; -import java.io.OutputStream; import java.io.PrintStream; import java.nio.file.Path; import ru.fusionsoft.dbgit.integration.primitives.Args; import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningProcessFrom; -public class PathAfterCommandRun extends PathPatched { - -// public PathAfterCommandRun(Args processRunCommandLine, Path origin) { -// super( -// origin, -// new PathPatchRunningProcessFrom(processRunCommandLine) -// ); -// } - - public PathAfterCommandRun(Args processRunCommandLine, PrintStream printStream, Path origin) { +public class PathAfterProcessRun extends PathPatched { + public PathAfterProcessRun(Args processRunCommandLine, PrintStream printStream, Path origin) { super( origin, new PathPatchRunningProcessFrom(processRunCommandLine, printStream) diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathNotProjectRoot.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathNotProjectRoot.java index 9bcbf6b..fbf43dc 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathNotProjectRoot.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathNotProjectRoot.java @@ -2,29 +2,14 @@ import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchAssertsNotMvnProjectRoot; -public class PathNotProjectRoot extends PathEnvelope{ +public class PathNotProjectRoot extends PathPatched{ public PathNotProjectRoot(Path origin) { - super(()-> { - if( - origin.resolve(".git").toFile().exists() && - origin.resolve("pom.xml").toFile().exists() - ){ - throw new PathIsProjectRootException(origin); - } - return origin; - }); + super(new PathPatchAssertsNotMvnProjectRoot(), origin); } - private static class PathIsProjectRootException extends RuntimeException { - PathIsProjectRootException(Path path) { - super( - "\nGiven path " + path.toString() + " " + - "points to a project root directory.\n" + - "I'm here not to allow that." - ); - } - } + } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOf.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOf.java index 617b5e2..25beada 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOf.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOf.java @@ -10,6 +10,6 @@ public PathOf(Scalar origin) { } public PathOf(String path, Path origin) { - super(()->origin.resolve(path)); + super(()->origin.resolve(path).toAbsolutePath()); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPatched.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPatched.java index 9cb38a2..c202c5e 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPatched.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathPatched.java @@ -11,4 +11,9 @@ public PathPatched(final Path origin, final Patch patch) { new PatchedScalar<>(origin, patch) ); } + public PathPatched(final Patch patch, final Path origin) { + super( + new PatchedScalar<>(origin, patch) + ); + } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitCheckoutAndLink.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitCheckoutAndLink.java deleted file mode 100644 index 8633ee5..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitCheckoutAndLink.java +++ /dev/null @@ -1,33 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.path; - -import java.io.PrintStream; -import java.nio.file.Path; -import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsCheckoutNodb; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsLink; - -public class PathWithDbGitCheckoutAndLink extends PathAfterDbGitRun { - public PathWithDbGitCheckoutAndLink( - ArgsCheckoutNodb checkoutArgs, - ArgsLink linkArgs, - PrintStream printStream, - Path origin - ) { - super( - linkArgs, - printStream, - new PathAfterDbGitRun( - checkoutArgs, - origin - ) - ); - } - - public PathWithDbGitCheckoutAndLink( - ArgsCheckoutNodb checkoutArgs, - ArgsLink linkArgs, - Path origin - ) { - this(checkoutArgs, linkArgs, new NullPrintStream(), origin); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitRepoInitialized.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitRepoInitialized.java deleted file mode 100644 index c1d27ae..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithDbGitRepoInitialized.java +++ /dev/null @@ -1,29 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.path; - -import java.nio.file.Path; -import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; - -public class PathWithDbGitRepoInitialized extends PathAfterDbGitRun { - public PathWithDbGitRepoInitialized(CharSequence repoUrl, Path origin) { - super( - new ArgsExplicit("init"), - - new PathAfterDbGitRun( - new ArgsExplicit( - "clone", - repoUrl, - "--directory", - "\"" + origin.toAbsolutePath().toString() + "\"" - ), - - new PathWithoutFiles( - "*", - new PathNotProjectRoot( - origin - ) - ) - - ) - ); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithFiles.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithFiles.java index 026080a..ae2d602 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithFiles.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithFiles.java @@ -1,22 +1,15 @@ package ru.fusionsoft.dbgit.integration.primitives.path; import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; import ru.fusionsoft.dbgit.integration.primitives.Scalar; import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; -public class PathWithFiles extends PathEnvelope { +public class PathWithFiles extends PathPatched { public PathWithFiles(PathPatchCreatingFile[] filePatches, Path origin) { - super(new Scalar() { - @Override - public Path value() throws Exception { - for (final PathPatchCreatingFile filePatch : filePatches) { - filePatch.apply(origin); - } - return origin; - } - }); + super(origin, new PatchSequential(filePatches)); } - public PathWithFiles(PathPatchCreatingFile file, Path origin){ - this(new PathPatchCreatingFile[]{file}, origin); + public PathWithFiles(PathPatchCreatingFile filePatch, Path origin){ + super(filePatch, origin); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithoutFiles.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithoutFiles.java index 210eb9f..49dd0d5 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithoutFiles.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithoutFiles.java @@ -4,23 +4,19 @@ import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFiles; import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFilesWildcard; -public class PathWithoutFiles extends PathEnvelope { +public class PathWithoutFiles extends PathPatched { public PathWithoutFiles(String[] names, Path origin) { super( - () -> { - new PathPatchDeletingFiles(names).apply(origin); - return origin; - } + new PathPatchDeletingFiles(names), + origin ); } - + public PathWithoutFiles(String filterMask, Path origin) { super( - () -> { - new PathPatchDeletingFilesWildcard(filterMask).apply(origin); - return origin; - } + new PathPatchDeletingFilesWildcard(filterMask), + origin ); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/ProjectTestResourcesCleanDirectoryPath.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/ProjectTestResourcesCleanDirectoryPath.java index 9437152..d671371 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/ProjectTestResourcesCleanDirectoryPath.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/ProjectTestResourcesCleanDirectoryPath.java @@ -26,7 +26,7 @@ public ProjectTestResourcesCleanDirectoryPath(String name) { ); directory.mkdirs(); FileUtils.cleanDirectory(directory); - return directory.toPath(); + return directory.toPath().toAbsolutePath(); }); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOfBuiltDbGitExecutable.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathOfBuiltDbGitExecutable.java similarity index 65% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOfBuiltDbGitExecutable.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathOfBuiltDbGitExecutable.java index 10fc080..fc3a796 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathOfBuiltDbGitExecutable.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathOfBuiltDbGitExecutable.java @@ -1,6 +1,7 @@ -package ru.fusionsoft.dbgit.integration.primitives.path; +package ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit; import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.path.PathOf; public class PathOfBuiltDbGitExecutable extends PathOf { public PathOfBuiltDbGitExecutable(Path dbGitProjectPath) { diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathWithDbGitNewRepoInitialized.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathWithDbGitNewRepoInitialized.java new file mode 100644 index 0000000..2a7031d --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathWithDbGitNewRepoInitialized.java @@ -0,0 +1,29 @@ +package ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRun; +import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; +import ru.fusionsoft.dbgit.integration.primitives.path.PathWithoutFiles; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; + +public class PathWithDbGitNewRepoInitialized extends PathAfterDbGitRun { + public PathWithDbGitNewRepoInitialized(PrintStream printStream, Path workingDirectory) { + super( + new ArgsExplicit("init"), + printStream, + + new PathWithoutFiles( + "*", + new PathNotProjectRoot( + workingDirectory + ) + ) + ); + } + + public PathWithDbGitNewRepoInitialized(Path workingDirectory) { + this(new DefaultPrintStream(), workingDirectory); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathWithDbGitRepoCloned.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathWithDbGitRepoCloned.java new file mode 100644 index 0000000..cbdfb70 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/PathWithDbGitRepoCloned.java @@ -0,0 +1,30 @@ +package ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemote; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitClonesRepo; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; + +public class PathWithDbGitRepoCloned extends PathPatched { + public PathWithDbGitRepoCloned(CharSequence repoUrl, ArgsDbGitAddRemote addRemoteArgs, PrintStream printStream, Path origin) { + super( + new PathPatchDbGitClonesRepo(repoUrl, addRemoteArgs, printStream), + origin + ); + } + public PathWithDbGitRepoCloned(CharSequence repoUrl, PrintStream printStream, Path origin) { + super( + new PathPatchDbGitClonesRepo(repoUrl, printStream), + origin + ); + } + public PathWithDbGitRepoCloned(CharSequence repoUrl, ArgsDbGitAddRemote addRemoteArgs, Path origin) { + this(repoUrl, addRemoteArgs, new DefaultPrintStream(), origin); + } + public PathWithDbGitRepoCloned(CharSequence repoUrl, Path origin) { + this(repoUrl, new DefaultPrintStream(), origin); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitCheckoutAndLink.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitCheckoutAndLink.java new file mode 100644 index 0000000..48df385 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitCheckoutAndLink.java @@ -0,0 +1,34 @@ +package ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.scenarios; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitCheckout; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLink; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRun; + +public class PathAfterDbGitCheckoutAndLink extends PathAfterDbGitRun { + public PathAfterDbGitCheckoutAndLink( + ArgsDbGitCheckout checkoutArgs, + ArgsDbGitLink linkArgs, + PrintStream printStream, + Path origin + ) { + super( + linkArgs, + printStream, + new PathAfterDbGitRun( + checkoutArgs, + origin + ) + ); + } + + public PathAfterDbGitCheckoutAndLink( + ArgsDbGitCheckout checkoutArgs, + ArgsDbGitLink linkArgs, + Path origin + ) { + this(checkoutArgs, linkArgs, new DefaultPrintStream(), origin); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitDumpsDbSchemaToGit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitDumpsDbSchemaToGit.java new file mode 100644 index 0000000..041af4e --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitDumpsDbSchemaToGit.java @@ -0,0 +1,41 @@ +package ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.scenarios; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Patch; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemote; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLink; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchRunningDbGit; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitLink; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.PathWithDbGitRepoCloned; + +public class PathAfterDbGitDumpsDbSchemaToGit extends PathPatched { + public PathAfterDbGitDumpsDbSchemaToGit( + CharSequence commitMessage, + CharSequence pushRemoteName, + CharSequence gitUrl, + ArgsDbGitLink dbLinkArgs, + ArgsDbGitAddRemote addRemoteArgs, + CharSequence ignoreChars, + Patch checkoutPatch, + PrintStream printStream, + Path workingDirectory + ) { + super( + new PatchSequential<>( + checkoutPatch, + new PathPatchDbGitLink(dbLinkArgs, printStream), + new PathPatchCreatingFile(".dbgit/.dbignore", ignoreChars), + new PathPatchRunningDbGit(new ArgsExplicit("add", "\"*\"", "-v"), printStream), + new PathPatchRunningDbGit(new ArgsExplicit("commit", "-m", commitMessage), printStream), + new PathPatchRunningDbGit(new ArgsExplicit("push", pushRemoteName),printStream) + ), + new PathWithDbGitRepoCloned(gitUrl, addRemoteArgs, printStream, workingDirectory) + ); + } + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitLinkAndAdd.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitLinkAndAdd.java new file mode 100644 index 0000000..36632f2 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathAfterDbGitLinkAndAdd.java @@ -0,0 +1,27 @@ +package ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.scenarios; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; +import ru.fusionsoft.dbgit.integration.primitives.path.PathWithFiles; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLink; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterDbGitRun; + +public class PathAfterDbGitLinkAndAdd extends PathAfterDbGitRun { + public PathAfterDbGitLinkAndAdd(ArgsDbGitLink argsDbGitLink, CharSequence ignoreChars, PrintStream printStream, Path origin) { + super( + new ArgsExplicit("add", "\"*\"", "-v"), + printStream, + new PathWithFiles( + new PathPatchCreatingFile(".dbgit/.dbignore", ignoreChars), + new PathAfterDbGitRun(argsDbGitLink, printStream, origin) + ) + ); + } + + public PathAfterDbGitLinkAndAdd(ArgsDbGitLink argsDbGitLink, CharSequence ignoreChars, Path origin) { + this(argsDbGitLink, ignoreChars, new DefaultPrintStream(), origin); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithBuildingDbGitExecutableFromGit.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathWithBuildingDbGitExecutableFromGit.java similarity index 73% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithBuildingDbGitExecutableFromGit.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathWithBuildingDbGitExecutableFromGit.java index 708011e..ce96dfc 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/PathWithBuildingDbGitExecutableFromGit.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/path/specific/dbgit/scenarios/PathWithBuildingDbGitExecutableFromGit.java @@ -1,14 +1,19 @@ -package ru.fusionsoft.dbgit.integration.primitives.path; +package ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.scenarios; import java.io.PrintStream; import java.nio.file.Path; -import ru.fusionsoft.dbgit.integration.primitives.NullPrintStream; -import ru.fusionsoft.dbgit.integration.primitives.PatchSequental; +import ru.fusionsoft.dbgit.integration.primitives.printstream.DefaultPrintStream; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsExplicit; import ru.fusionsoft.dbgit.integration.primitives.args.ArgsWithPrepend; import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCloningGitRepo; import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFiles; import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchDeletingFilesWildcard; +import ru.fusionsoft.dbgit.integration.primitives.path.PathAfterProcessRun; +import ru.fusionsoft.dbgit.integration.primitives.path.PathEnvelope; +import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.PathOfBuiltDbGitExecutable; +import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; public class PathWithBuildingDbGitExecutableFromGit extends PathEnvelope { @@ -16,7 +21,7 @@ public PathWithBuildingDbGitExecutableFromGit(String commitHash, PrintStream pri super(() -> { return new PathOfBuiltDbGitExecutable( - new PathAfterCommandRun( + new PathAfterProcessRun( new ArgsWithPrepend( new ArgsExplicit( "mvn", @@ -33,7 +38,7 @@ public PathWithBuildingDbGitExecutableFromGit(String commitHash, PrintStream pri printStream, new PathPatched( new PathNotProjectRoot(origin), - new PatchSequental( + new PatchSequential<>( new PathPatchDeletingFilesWildcard( "*" ), @@ -54,6 +59,6 @@ public PathWithBuildingDbGitExecutableFromGit(String commitHash, PrintStream pri } public PathWithBuildingDbGitExecutableFromGit(String commitHash, Path origin) { - this(commitHash, new NullPrintStream(), origin); + this(commitHash, new DefaultPrintStream(), origin); } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/DefaultPrintStream.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/DefaultPrintStream.java new file mode 100644 index 0000000..288b0eb --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/DefaultPrintStream.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.printstream; + +import java.io.PrintStream; + +public class DefaultPrintStream extends PrintStream { + public DefaultPrintStream() { + super(new PrintStreamToConsole()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/OutputStreamToConsole.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/OutputStreamToConsole.java new file mode 100644 index 0000000..5719464 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/OutputStreamToConsole.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.primitives.printstream; + +import java.io.OutputStream; + +public class OutputStreamToConsole extends OutputStream { + @Override + public final void write(int i) { + System.out.write(i); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/OutputStreamToNowhere.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/OutputStreamToNowhere.java new file mode 100644 index 0000000..dd8b931 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/OutputStreamToNowhere.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.printstream; + +import java.io.OutputStream; + +public class OutputStreamToNowhere extends OutputStream { + @Override + public void write(int b) { + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/PrintStreamToConsole.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/PrintStreamToConsole.java new file mode 100644 index 0000000..d06d72d --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/PrintStreamToConsole.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.printstream; + +import java.io.PrintStream; + +public class PrintStreamToConsole extends PrintStream { + public PrintStreamToConsole() { + super(new OutputStreamToConsole()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/PrintStreamToNowhere.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/PrintStreamToNowhere.java new file mode 100644 index 0000000..ae5f3c3 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/printstream/PrintStreamToNowhere.java @@ -0,0 +1,10 @@ +package ru.fusionsoft.dbgit.integration.primitives.printstream; + +import java.io.PrintStream; + +public class PrintStreamToNowhere extends PrintStream { + + public PrintStreamToNowhere() { + super(new OutputStreamToNowhere()); + } +} From d634c9dcf94518115be5e0de42ca7faeca0f3f31 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 26 May 2021 13:14:55 +0300 Subject: [PATCH 48/68] Quick fix for @rultor support --- .rultor.yml | 16 +++++++++ pom.xml | 34 +++++-------------- .../DbGitIntegrationTestBasic.java | 3 -- .../dbgit/integration/SelfTest.java | 6 ++-- .../primitives/args/ArgsRunningCommand.java | 4 +-- 5 files changed, 29 insertions(+), 34 deletions(-) create mode 100644 .rultor.yml diff --git a/.rultor.yml b/.rultor.yml new file mode 100644 index 0000000..5f067f3 --- /dev/null +++ b/.rultor.yml @@ -0,0 +1,16 @@ +env: + MAVEN_OPTS: "-XX:MaxPermSize=256m -Xmx1g" +assets: + pgSecret.txt: rocket-3/dbgit-test#pgSecret.txt + gitSecret.txt: rocket-3/dbgit-test#gitSecret.txt +merge: + script: |- + java -version + mvn -version + mvn clean install package appassembler:assemble -D skipTests +deploy: + script: |- + java -version + mvn -version + mvn clean install package appassembler:assemble -D skipTests + mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* diff --git a/pom.xml b/pom.xml index 4c26c60..d0efc3f 100644 --- a/pom.xml +++ b/pom.xml @@ -11,16 +11,7 @@ org.apache.maven.plugins maven-surefire-plugin - 3.0.0-M5 - - none() | integration - deprecated - - - - - maven-failsafe-plugin - 3.0.0-M5 + 2.22.2 @@ -156,7 +147,6 @@ - org.apache.commons @@ -226,22 +216,10 @@ 1.4 - - - - - - org.junit.jupiter - junit-jupiter-engine - 5.6.2 - - - - org.junit.jupiter - junit-jupiter-api - 5.6.2 + junit-jupiter + 5.7.2 @@ -294,6 +272,12 @@ jsr305 3.0.0 + + org.junit.platform + junit-platform-commons + 1.7.0 + compile + diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java index bd12b9b..1ad23f6 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java @@ -18,11 +18,9 @@ import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLinkPgAuto; import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemoteTestRepo; import ru.fusionsoft.dbgit.integration.primitives.chars.CommitsFromRepo; -import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.CharsOfLines; import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LinesOf; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckout; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitClonesRepo; -import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitReset; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitRestore; import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfConsoleWhenRunning; import ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit.CharsDbIgnoreWithTableData; @@ -40,7 +38,6 @@ import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.PathWithDbGitRepoCloned; import ru.fusionsoft.dbgit.integration.primitives.path.PathWithoutFiles; import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; -import ru.fusionsoft.dbgit.integration.primitives.printstream.PrintStreamToConsole; @Tag("integration") public class DbGitIntegrationTestBasic { diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java index 78388e6..45c7370 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java @@ -84,7 +84,6 @@ public void apply(Path root) throws Exception { ) ); - System.out.println(testResult.text()); Assertions.assertFalse(testResult.value()); } ); @@ -119,7 +118,6 @@ public final void groupedTestResultWorks() { } ) ); - System.out.println(result.text()); Assertions.assertFalse(result.value()); } @@ -141,13 +139,13 @@ public final void patchedWorks() { ), new SimpleTest<>( - "Файл существует", + "File exists", path -> { return path.resolve(fileName).toFile().exists(); } ), new SimpleTest<>( - "Содержимое файла как ожидалось", + "File content as expected", path -> { return FileUtils.readFileToString( path.resolve(fileName).toFile() diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java index f620a85..7c1cb09 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java @@ -7,8 +7,8 @@ public class ArgsRunningCommand extends ArgsExplicit { public ArgsRunningCommand(CharSequence commandName) { super( - System.getenv("ComSpec"), - "/C", + (System.getenv("ComSpec") == null) ? "sh" : System.getenv("ComSpec"), + (System.getenv("ComSpec") == null) ? "-c" : "/C", commandName ); } From b169524170b19c0c1e575d64e49ed84cade6232f Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 26 May 2021 14:08:22 +0300 Subject: [PATCH 49/68] Fix reading process inputstreams for IT running properly --- .../chars/LinesFromInputStream.java | 9 +++++-- .../patch/PathPatchRunningProcessFrom.java | 25 +++++++++---------- 2 files changed, 19 insertions(+), 15 deletions(-) diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java index f3db956..e87ee87 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java @@ -3,6 +3,8 @@ import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; +import java.util.Collections; +import java.util.LinkedList; import java.util.List; import java.util.stream.Collectors; import ru.fusionsoft.dbgit.integration.primitives.Scalar; @@ -20,8 +22,11 @@ public LinesFromInputStream(InputStream origin, String codepageName) { ? new InputStreamReader(origin) : new InputStreamReader(origin, codepageName) ) - ) { - return reader.lines().collect(Collectors.toList()); + ) { + final LinkedList lines = new LinkedList<>(); + String line; + while (( line = reader.readLine() ) != null) lines.add(line); + return lines; } } ); diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java index 9d0ae70..12cd441 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java @@ -48,22 +48,21 @@ public final void apply(Path root) throws Exception { )); final Process process = new ProcessBuilder() - .directory(root.toAbsolutePath().toFile()) - .command( - Arrays.stream(processRunCommandLine.values()) - .map(String::valueOf) - .collect(Collectors.toList()) - ) - .start(); + .directory(root.toAbsolutePath().toFile()) + .command( + Arrays.stream(processRunCommandLine.values()) + .map(String::valueOf) + .collect(Collectors.toList()) + ) + .start(); + process.getOutputStream().close(); - final CharSequence processOutput = String.valueOf( - new CharsOfLines( - new LinesFromInputStream(process.getInputStream()), "> " - ) - ); + final CharSequence processOutput = new CharsOfLines( + new LinesFromInputStream(process.getInputStream(), "Utf-8"), "> " + ).toString(); final CharSequence processErrOutput = new CharsOfLines( new LinesFromInputStream(process.getErrorStream(), "Utf-8"), "> " - ); + ).toString(); final int exitCode = process.waitFor(); process.destroyForcibly(); From 93b1b17f48d9f9067125969845bf388855fb02b6 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 26 May 2021 14:12:22 +0300 Subject: [PATCH 50/68] Rm color codes from output --- .rultor.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index 5f067f3..0aaee5c 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -5,12 +5,12 @@ assets: gitSecret.txt: rocket-3/dbgit-test#gitSecret.txt merge: script: |- - java -version - mvn -version - mvn clean install package appassembler:assemble -D skipTests + java -version --batch-mode + mvn -version --batch-mode + mvn clean install package appassembler:assemble -D skipTests --batch-mode deploy: script: |- java -version mvn -version - mvn clean install package appassembler:assemble -D skipTests - mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* + mvn clean install package appassembler:assemble -D skipTests --batch-mode + mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode From 74f5c6ab8592028ab47fa873da36f798f6d232c7 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 26 May 2021 14:15:14 +0300 Subject: [PATCH 51/68] Test before merge --- .rultor.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.rultor.yml b/.rultor.yml index 0aaee5c..0045b46 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -8,6 +8,7 @@ merge: java -version --batch-mode mvn -version --batch-mode mvn clean install package appassembler:assemble -D skipTests --batch-mode + mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode deploy: script: |- java -version From 60d5a2fefee6937586d0333bcdce6a4176d7c5cb Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 26 May 2021 14:12:22 +0300 Subject: [PATCH 52/68] Rm color codes from output --- .rultor.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index 5f067f3..0aaee5c 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -5,12 +5,12 @@ assets: gitSecret.txt: rocket-3/dbgit-test#gitSecret.txt merge: script: |- - java -version - mvn -version - mvn clean install package appassembler:assemble -D skipTests + java -version --batch-mode + mvn -version --batch-mode + mvn clean install package appassembler:assemble -D skipTests --batch-mode deploy: script: |- java -version mvn -version - mvn clean install package appassembler:assemble -D skipTests - mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* + mvn clean install package appassembler:assemble -D skipTests --batch-mode + mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode From 3c9d91fda866b6a19f3cac181ea345cf5000bcfd Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 26 May 2021 14:15:14 +0300 Subject: [PATCH 53/68] Test before merge --- .rultor.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.rultor.yml b/.rultor.yml index 0aaee5c..0045b46 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -8,6 +8,7 @@ merge: java -version --batch-mode mvn -version --batch-mode mvn clean install package appassembler:assemble -D skipTests --batch-mode + mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode deploy: script: |- java -version From 6c8de42f9a60bd826a3e436d92d361af2b51a432 Mon Sep 17 00:00:00 2001 From: rocket-3 <47713503+rocket-3@users.noreply.github.com> Date: Wed, 26 May 2021 20:08:16 +0300 Subject: [PATCH 54/68] Update .rultor.yml to fix built application permission denied --- .rultor.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index 0045b46..f5cffd0 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -8,10 +8,12 @@ merge: java -version --batch-mode mvn -version --batch-mode mvn clean install package appassembler:assemble -D skipTests --batch-mode + chmod u+r+x /target/dbgit/bin/dbgit mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode deploy: script: |- - java -version - mvn -version + java -version --batch-mode + mvn -version --batch-mode mvn clean install package appassembler:assemble -D skipTests --batch-mode + chmod u+r+x /target/dbgit/bin/dbgit mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode From 5f5a97030b80ef6df0a63544490ccd7fbd9a3941 Mon Sep 17 00:00:00 2001 From: rocket-3 <47713503+rocket-3@users.noreply.github.com> Date: Wed, 26 May 2021 20:14:57 +0300 Subject: [PATCH 55/68] Update .rultor.yml --- .rultor.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index f5cffd0..e0464c1 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -8,12 +8,12 @@ merge: java -version --batch-mode mvn -version --batch-mode mvn clean install package appassembler:assemble -D skipTests --batch-mode - chmod u+r+x /target/dbgit/bin/dbgit + chmod u+r+x target/dbgit/bin/dbgit mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode deploy: script: |- java -version --batch-mode mvn -version --batch-mode mvn clean install package appassembler:assemble -D skipTests --batch-mode - chmod u+r+x /target/dbgit/bin/dbgit + chmod u+r+x target/dbgit/bin/dbgit mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode From aea0998da5d268678d44445876bab1d9fcd4a7d6 Mon Sep 17 00:00:00 2001 From: rocket Date: Sun, 30 May 2021 16:18:23 +0300 Subject: [PATCH 56/68] Fix ArgsRunningCommand.java for unix support Fix PathPatchRunningProcessFrom.java getting stuck with process input streams Fix ReportOfTest*.java for better log processing Fix some error and log messaging --- src/main/java/ru/fusionsoft/dbgit/App.java | 4 +- .../dbgit/adapters/DBBackupAdapter.java | 1 - .../ru/fusionsoft/dbgit/meta/IMetaObject.java | 1 - .../fusionsoft/dbgit/meta/MetaTableData.java | 8 +- .../postgres/DBRestoreTableDataPostgres.java | 1181 ++++++++--------- .../DbGitIntegrationTestBasic.java | 8 +- .../dbgit/integration/SelfTest.java | 15 + .../primitives/GroupedTestResult.java | 9 +- .../primitives/StickyFunction.java | 4 +- .../primitives/args/ArgsRunningCommand.java | 17 +- .../chars/CharsOfConsoleWhenRunning.java | 14 +- .../primitives/chars/CharsOfLines.java | 38 + .../primitives/chars/CharsWithBoundary.java | 9 + .../chars/{specific/test => }/Lines.java | 2 +- .../chars/LinesFromInputStream.java | 15 +- .../{specific/test => }/LinesOfString.java | 3 +- .../primitives/chars/LinesOfUnsafeScalar.java | 18 + .../chars/specific/test/CharsOfLines.java | 21 - .../chars/specific/test/LinesOf.java | 18 - .../specific/test/ReportOfTestFormat.java | 11 +- .../specific/test/ReportOfTestGroupRun.java | 7 +- .../chars/specific/test/ReportOfTestRun.java | 29 +- .../files/AutoDeletingTempFilePath.java | 33 + .../patch/PathPatchRunningProcessFrom.java | 76 +- 24 files changed, 799 insertions(+), 743 deletions(-) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfLines.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsWithBoundary.java rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/{specific/test => }/Lines.java (56%) rename src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/{specific/test => }/LinesOfString.java (72%) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesOfUnsafeScalar.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/CharsOfLines.java delete mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOf.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/AutoDeletingTempFilePath.java diff --git a/src/main/java/ru/fusionsoft/dbgit/App.java b/src/main/java/ru/fusionsoft/dbgit/App.java index 38bc237..0c2f173 100644 --- a/src/main/java/ru/fusionsoft/dbgit/App.java +++ b/src/main/java/ru/fusionsoft/dbgit/App.java @@ -32,13 +32,13 @@ public static void main( String[] args ) { .getValue("errors", "executionError") .toString(); - LoggerUtil.getGlobalLogger().error(msg, e); System.err.println(MessageFormat.format( - "{0}:\n{1}", + "\n{0}: {1}", msg, ExceptionUtils.readStackTrace(e) )); + LoggerUtil.getGlobalLogger().error(msg, e); rollbackConnection(); System.exit(1); } finally { diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java index 6efd7b4..10db25e 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBBackupAdapter.java @@ -52,7 +52,6 @@ public boolean isExists(IMetaObject imo) { try { return isExists(nm.getSchema(), nm.getName()); } catch (Exception ex){ - ex.printStackTrace(); throw new RuntimeException(ex); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java index c5c7354..7e5468b 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/IMetaObject.java @@ -116,7 +116,6 @@ default boolean saveToFile(String basePath) throws ExceptionDBGit { return res; } catch (Exception e) { - e.printStackTrace(); throw new ExceptionDBGit(e); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index bc8d8cf..f547312 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -304,8 +304,9 @@ public boolean loadPortionFromDB(int currentPortionIndex, int tryNumber) throws return loadPortionFromDB(currentPortionIndex, tryNumber++); } } catch (Exception e1) { + throw new ExceptionDBGitRunTime(e1); // TODO Auto-generated catch block - e1.printStackTrace(); +// e1.printStackTrace(); } if (e instanceof ExceptionDBGit) throw (ExceptionDBGit)e; @@ -346,10 +347,7 @@ public boolean loadFromDB() throws ExceptionDBGit { System.out.println(); */ } catch (Exception e) { - e.printStackTrace(); - if (e instanceof ExceptionDBGit) - throw (ExceptionDBGit)e; - throw new ExceptionDBGit(e); + throw new ExceptionDBGit("Error loading table data from DB", e); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index fd88d67..a303494 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -1,592 +1,589 @@ -package ru.fusionsoft.dbgit.postgres; - -import java.io.BufferedReader; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStreamReader; -import java.sql.Connection; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.text.MessageFormat; -import java.text.SimpleDateFormat; -import java.util.*; -import java.util.stream.Collectors; - -import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.adapters.IDBAdapter; -import ru.fusionsoft.dbgit.core.*; -import ru.fusionsoft.dbgit.data_table.BooleanData; -import ru.fusionsoft.dbgit.data_table.DateData; -import ru.fusionsoft.dbgit.data_table.ICellData; -import ru.fusionsoft.dbgit.data_table.LongData; -import ru.fusionsoft.dbgit.data_table.MapFileData; -import ru.fusionsoft.dbgit.data_table.RowData; -import ru.fusionsoft.dbgit.data_table.StringData; -import ru.fusionsoft.dbgit.data_table.TextFileData; -import ru.fusionsoft.dbgit.data_table.TreeMapRowData; -import ru.fusionsoft.dbgit.dbobjects.DBConstraint; -import ru.fusionsoft.dbgit.dbobjects.DBTableField; -import ru.fusionsoft.dbgit.meta.IMetaObject; -import ru.fusionsoft.dbgit.meta.MetaTable; -import ru.fusionsoft.dbgit.meta.MetaTableData; -import ru.fusionsoft.dbgit.meta.NameMeta; -import ru.fusionsoft.dbgit.statement.PrepareStatementLogging; -import ru.fusionsoft.dbgit.statement.StatementLogging; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -import com.google.common.collect.MapDifference; -import com.google.common.collect.MapDifference.ValueDifference; -import com.google.common.collect.Maps; - -public class DBRestoreTableDataPostgres extends DBRestoreAdapter { - - @Override - public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - if (obj instanceof MetaTableData) { - MetaTableData currentTableData; - MetaTableData restoreTableData = (MetaTableData)obj; - GitMetaDataManager gitMetaMng = GitMetaDataManager.getInstance(); - //TODO не факт что в кеше есть мета описание нашей таблицы, точнее ее не будет если при старте ресторе таблицы в бд не было совсем - - IMetaObject currentMetaObj = gitMetaMng.getCacheDBMetaObject(obj.getName()); - - if (currentMetaObj == null || currentMetaObj instanceof MetaTableData) { - - if(Integer.valueOf(step).equals(0)) { - removeTableConstraintsPostgres(restoreTableData.getMetaTable()); - return false; - } - if(Integer.valueOf(step).equals(1)) { - String schema = getPhisicalSchema(restoreTableData.getTable().getSchema()); - schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); - - if (currentMetaObj != null) { - currentTableData = (MetaTableData) currentMetaObj; - } else { - currentTableData = new MetaTableData(); - currentTableData.setTable(restoreTableData.getTable()); - currentTableData.getTable().setSchema(schema); - - currentTableData.setMapRows(new TreeMapRowData()); - currentTableData.setDataTable(restoreTableData.getDataTable()); - } - //clears restoreTableData->getDataTable() too after ^ "else" clause - currentTableData.getmapRows().clear(); - - if (getAdapter().getTable(schema, currentTableData.getTable().getName()) != null) { - //actually load data from database - currentTableData.setDataTable(getAdapter().getTableData(schema, currentTableData.getTable().getName())); - - ResultSet rs = currentTableData.getDataTable().resultSet(); - - TreeMapRowData mapRows = new TreeMapRowData(); - - MetaTable metaTable = new MetaTable(currentTableData.getTable()); - //ALSO loads data from database if fields vary - metaTable.loadFromDB(currentTableData.getTable()); - - if (rs != null) { - while(rs.next()) { - RowData rd = new RowData(rs, metaTable); - mapRows.put(rd.calcRowKey(metaTable.getIdColumns()), rd); - } - } - currentTableData.setMapRows(mapRows); - } - /* - ConsoleWriter.println("curr:"); - currentTableData.getmapRows().keySet().forEach(key -> ConsoleWriter.println("hash: " + key)); - ConsoleWriter.println("rest:"); - restoreTableData.getmapRows().keySet().forEach(key -> ConsoleWriter.println("hash: " + key)); - */ - restoreTableDataPostgres(restoreTableData,currentTableData); - return false; - } - if(Integer.valueOf(step).equals(-2)) { - restoreTableConstraintPostgres(restoreTableData.getMetaTable()); - return false; - } - return true; - } - else - { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( - obj.getName() - , "table data cached", obj.getType().getValue() - )); - } - } - else - { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( - obj.getName() - , "table data", obj.getType().getValue() - )); - } - } - - public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ - List fieldsList = restoreTableData.getFields(); -// System.err.println("fieldsList = " + String.join(",", fieldsList)); - if(fieldsList.size() == 0 ) { - ConsoleWriter.printlnRed(DBGitLang.getInstance() - .getValue("errors", "restore", "emptyFieldsList") - , 1 - ); - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - return; - } - if (restoreTableData.getmapRows() == null) { - ConsoleWriter.printlnRed(DBGitLang.getInstance() - .getValue("errors", "restore", "emptyRowsList") - , 1 - ); - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - return; - } - - IDBAdapter adapter = getAdapter(); - Connection connect = adapter.getConnection(); - - MapDifference diffTableData = Maps.difference(restoreTableData.getmapRows(), currentTableData.getmapRows()); - try (StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql())) { - - String schema = getPhisicalSchema(restoreTableData.getTable().getSchema()); - String tblNameEscaped = adapter.escapeNameIfNeeded(schema) + "." + adapter.escapeNameIfNeeded(restoreTableData.getTable().getName()); - String fields = getFieldsPrefix(restoreTableData); - Map colTypes = getColumnDataTypes(restoreTableData.getMetaTable(), st); - Set keyNames = restoreTableData.getMetaTable().getFields().values().stream() - .filter(DBTableField::getIsPrimaryKey) - .map(DBTableField::getName) - .collect(Collectors.toSet()); - - System.out.println("\ndiffTableData.entriesOnlyOnRight().isEmpty() = " - + diffTableData.entriesOnlyOnRight().isEmpty()); - //DELETE - if (!diffTableData.entriesOnlyOnRight().isEmpty()) { - ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); - StringBuilder deleteQuery = new StringBuilder(); - - for (RowData rowData : diffTableData.entriesOnlyOnRight().values()) { - StringJoiner fieldJoiner = new StringJoiner(","); - StringJoiner valuejoiner = new StringJoiner(","); - - for( Map.Entry entry : rowData.getData(fieldsList).entrySet()) { - if (keyNames.contains(entry.getKey())) { - fieldJoiner.add("\"" + entry.getKey() + "\""); - valuejoiner.add(entry.getValue().convertToString()); - } - } - - String delFields = "(" + fieldJoiner.toString() + ")"; - String delValues = "(" + valuejoiner.toString() + ")"; - - if (delValues.length() > 2){ - deleteQuery.append("DELETE FROM ").append(tblNameEscaped) - .append(" WHERE ").append(delFields).append(" = ") - .append(delValues).append(";\n"); - } - if (deleteQuery.length() > 50000) { - ConsoleWriter.detailsPrintln(deleteQuery, messageLevel + 1); - st.execute(deleteQuery.toString()); - deleteQuery = new StringBuilder(); - } - } - if (deleteQuery.length() > 1) { - ConsoleWriter.detailsPrintln(deleteQuery, messageLevel + 1); - st.execute(deleteQuery.toString()); - } - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - } - - System.out.println("\nentriesDiffering().isEmpty() = " - + diffTableData.entriesDiffering().isEmpty()); - //UPDATE - ConsoleWriter.detailsPrintln("Entries differing count: " + diffTableData.entriesDiffering().keySet().size(), messageLevel); - if (!diffTableData.entriesDiffering().isEmpty()) { - ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "updating"), messageLevel); - String updateQuery = ""; - Map primarykeys = new HashMap(); - - for (ValueDifference diffRowData : diffTableData.entriesDiffering().values()) { - if (!diffRowData.leftValue().getHashRow().equals(diffRowData.rightValue().getHashRow())) { - - Map tempCols = diffRowData.leftValue().getData(fieldsList); - for (String key : tempCols.keySet()) { - if (tempCols.get(key) == null || tempCols.get(key).convertToString() == null) continue; - if (keyNames.contains(key)) { - primarykeys.put(key, tempCols.get(key).convertToString()); - tempCols.remove(key); - } - } - - - if (!tempCols.isEmpty()) { - StringJoiner keyFieldsJoiner = new StringJoiner(","); - StringJoiner keyValuesJoiner = new StringJoiner(","); - for (Map.Entry entry : primarykeys.entrySet()) { - keyFieldsJoiner.add("\"" + entry.getKey() + "\""); - keyValuesJoiner.add("\'" + entry.getValue() + "\'"); - } - primarykeys.clear(); - - - StringJoiner updFieldJoiner = new StringJoiner(","); - tempCols.forEach( (key, value) -> { - updFieldJoiner.add("\"" + key + "\""); - }); - - - updateQuery = "UPDATE " + tblNameEscaped + " SET (" + updFieldJoiner.toString() + ") = " - + valuesToString(tempCols.values(), colTypes, fieldsList) + " " - + "WHERE (" + keyFieldsJoiner.toString() + ") = (" + keyValuesJoiner.toString() + ");\n"; - - - ConsoleWriter.detailsPrintln(updateQuery, messageLevel); - st.execute(updateQuery); - updateQuery = ""; - } - - } - } - - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - if (updateQuery.length() > 1) { - ConsoleWriter.println(updateQuery, messageLevel); - st.execute(updateQuery); - } - } - - //INSERT - if (!diffTableData.entriesOnlyOnLeft().isEmpty()) { - ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "inserting"), messageLevel); - for (RowData rowData : diffTableData.entriesOnlyOnLeft().values()) { - - String insertQuery = MessageFormat.format("INSERT INTO {0}{1}{2};" - , tblNameEscaped, fields - , valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) - ); - - ConsoleWriter.detailsPrintln(insertQuery, messageLevel+1); - st.execute(insertQuery); - } - ConsoleWriter.detailsPrintln(lang.getValue("general", "ok"), messageLevel); - } - - } catch (Exception e) { - throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()) - , e - ); - } - } - - public String valuesToString(Collection datas, Map colTypes, List fieldsList) throws ExceptionDBGit, IOException { - String values="("; - StringJoiner joiner = new StringJoiner(","); - int i = 0; - for (ICellData data : datas) { - boolean isBoolean = ((colTypes.get(fieldsList.get(i)) != null) && (colTypes.get(fieldsList.get(i)).toLowerCase().contains("boolean"))); - - if (data instanceof TextFileData) { - if (((TextFileData) data).getFile() == null || ((TextFileData) data).getFile().getName().contains("null")) { - //TODO generalize this behaviour based on some parameter - //TODO nulls if nullable, '' if not - joiner.add("''"); - } else { - FileInputStream fis = new FileInputStream(((MapFileData) data).getFile()); - BufferedReader br = new BufferedReader(new InputStreamReader(fis)); - - StringBuilder sb = new StringBuilder(); - String line; - while(( line = br.readLine()) != null ) { - sb.append( line ); - sb.append( '\n' ); - } - br.close(); - - fis.close(); - String res = "'" + sb.toString().replace("'", "''") - .replace("\\", "\\\\") -// .replace("\n", "' || chr(10) || '") - .replace("\0", "' || '\\000' || '") - + "'"; - - if (res.endsWith(" || chr(10) || ''")) { - res = res.substring(0, res.length() - " || chr(10) || ''".length()); - } - joiner.add(res); - - - } - } else if (data instanceof MapFileData) { - if (((MapFileData) data).getFile() == null || ((MapFileData) data).getFile().getName().contains("null")) { - joiner.add("null"); - } else { - - FileInputStream fis = new FileInputStream(((MapFileData) data).getFile()); - - int byteRead; - StringBuilder sb = new StringBuilder(); - - while ((byteRead = fis.read()) != -1) { - String hex = Integer.toHexString(byteRead); - if (hex.length() == 1) hex = "0" + hex; - - sb.append(hex); - } - fis.close(); - joiner.add("decode('" + sb.toString() + "', 'hex')"); - - /* - joiner1.add("decode('" + sb.toString().replace("'", "''") - .replace("\\", "\\\\") - .replace("\n", "' || chr(10) || '") - .replace("\0", "' || '\\000' || '") - + "', 'escape')");*/ - } - } else if (data instanceof DateData) { - Date date = ((DateData) data).getDate(); - SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); - if (date != null) - joiner.add("TO_TIMESTAMP('" + format.format(date) + "', 'YYYYMMDDHH24MISS')"); - else - joiner.add("null"); - } else if (data instanceof BooleanData) { - if (((BooleanData) data).getValue() != null) - joiner.add(((BooleanData) data).getValue().toString()); - else - joiner.add("null"); - } else if (data instanceof LongData) { - String dt = data.getSQLData().replace("'", ""); - - if (isBoolean) { - if (dt == null || dt.equals("")) - joiner.add("null"); - else if (dt.equals("1")) - joiner.add("true"); - else - joiner.add("false"); - } else { - if (!dt.equals("")) - joiner.add(dt); - else - joiner.add("null"); - } - } else { - String dt = ((StringData) data).getValue(); - if (isBoolean) { - if (dt == null || dt.equals("")) - joiner.add("null"); - else if (dt.startsWith("t") || dt.startsWith("T") || dt.equals("1") || dt.startsWith("y") || dt.startsWith("Y")) - joiner.add("true"); - else - joiner.add("false"); - } else { - if (dt != null) - joiner.add("'" + dt.replace("'", "''") + "'"); - else - joiner.add("null"); - } - //joiner.add(data.getSQLData()); - - } - - //joiner.add("?"); - i++; - } - //ConsoleWriter.println("joiner: " + joiner1); - values+=joiner.toString()+")"; - return values; - } - - public String keysToString(Set keys) { - String fields=""; - if(keys.size()>1) { - String[] fieldsArray = keys.toArray(new String[keys.size()]); - fields="("+(fieldsArray[0].equals(fieldsArray[0].toLowerCase()) ? fieldsArray[0] : "\"" + fieldsArray[0] + "\""); - for(int i=1;i e.getValue().getOrder())) - .map(entry -> adapter.escapeNameIfNeeded(entry.getValue().getName())) - .collect(Collectors.joining(", ")) - ); - } - - private Map getColumnDataTypes(MetaTable tbl, StatementLogging st) throws SQLException { - HashMap colTypes = new HashMap(); - NameMeta nm = new NameMeta(tbl); - nm.setSchema(nm.getSchema()); - - ResultSet rsTypes = st.executeQuery(MessageFormat.format( - " select column_name, data_type from information_schema.columns \r\n" + - " where lower(table_schema) = lower(''{0}'') AND lower(table_name) = lower(''{1}'')" - , nm.getSchema(), nm.getName() - )); - - while (rsTypes.next()) { - colTypes.put(rsTypes.getString("column_name"), rsTypes.getString("data_type")); - } - return colTypes; - } - - -} +package ru.fusionsoft.dbgit.postgres; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.text.MessageFormat; +import java.text.SimpleDateFormat; +import java.util.*; +import java.util.stream.Collectors; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.*; +import ru.fusionsoft.dbgit.data_table.BooleanData; +import ru.fusionsoft.dbgit.data_table.DateData; +import ru.fusionsoft.dbgit.data_table.ICellData; +import ru.fusionsoft.dbgit.data_table.LongData; +import ru.fusionsoft.dbgit.data_table.MapFileData; +import ru.fusionsoft.dbgit.data_table.RowData; +import ru.fusionsoft.dbgit.data_table.StringData; +import ru.fusionsoft.dbgit.data_table.TextFileData; +import ru.fusionsoft.dbgit.data_table.TreeMapRowData; +import ru.fusionsoft.dbgit.dbobjects.DBConstraint; +import ru.fusionsoft.dbgit.dbobjects.DBTableField; +import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaTable; +import ru.fusionsoft.dbgit.meta.MetaTableData; +import ru.fusionsoft.dbgit.meta.NameMeta; +import ru.fusionsoft.dbgit.statement.PrepareStatementLogging; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +import com.google.common.collect.MapDifference; +import com.google.common.collect.MapDifference.ValueDifference; +import com.google.common.collect.Maps; + +public class DBRestoreTableDataPostgres extends DBRestoreAdapter { + + @Override + public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + if (obj instanceof MetaTableData) { + MetaTableData currentTableData; + MetaTableData restoreTableData = (MetaTableData)obj; + GitMetaDataManager gitMetaMng = GitMetaDataManager.getInstance(); + //TODO не факт что в кеше есть мета описание нашей таблицы, точнее ее не будет если при старте ресторе таблицы в бд не было совсем + + IMetaObject currentMetaObj = gitMetaMng.getCacheDBMetaObject(obj.getName()); + + if (currentMetaObj == null || currentMetaObj instanceof MetaTableData) { + + if(Integer.valueOf(step).equals(0)) { + removeTableConstraintsPostgres(restoreTableData.getMetaTable()); + return false; + } + if(Integer.valueOf(step).equals(1)) { + String schema = getPhisicalSchema(restoreTableData.getTable().getSchema()); + schema = (SchemaSynonym.getInstance().getSchema(schema) == null) ? schema : SchemaSynonym.getInstance().getSchema(schema); + + if (currentMetaObj != null) { + currentTableData = (MetaTableData) currentMetaObj; + } else { + currentTableData = new MetaTableData(); + currentTableData.setTable(restoreTableData.getTable()); + currentTableData.getTable().setSchema(schema); + + currentTableData.setMapRows(new TreeMapRowData()); + currentTableData.setDataTable(restoreTableData.getDataTable()); + } + //clears restoreTableData->getDataTable() too after ^ "else" clause + currentTableData.getmapRows().clear(); + + if (getAdapter().getTable(schema, currentTableData.getTable().getName()) != null) { + //actually load data from database + currentTableData.setDataTable(getAdapter().getTableData(schema, currentTableData.getTable().getName())); + + ResultSet rs = currentTableData.getDataTable().resultSet(); + + TreeMapRowData mapRows = new TreeMapRowData(); + + MetaTable metaTable = new MetaTable(currentTableData.getTable()); + //ALSO loads data from database if fields vary + metaTable.loadFromDB(currentTableData.getTable()); + + if (rs != null) { + while(rs.next()) { + RowData rd = new RowData(rs, metaTable); + mapRows.put(rd.calcRowKey(metaTable.getIdColumns()), rd); + } + } + currentTableData.setMapRows(mapRows); + } + /* + ConsoleWriter.println("curr:"); + currentTableData.getmapRows().keySet().forEach(key -> ConsoleWriter.println("hash: " + key)); + ConsoleWriter.println("rest:"); + restoreTableData.getmapRows().keySet().forEach(key -> ConsoleWriter.println("hash: " + key)); + */ + restoreTableDataPostgres(restoreTableData,currentTableData); + return false; + } + if(Integer.valueOf(step).equals(-2)) { + restoreTableConstraintPostgres(restoreTableData.getMetaTable()); + return false; + } + return true; + } + else + { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data cached", obj.getType().getValue() + )); + } + } + else + { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName() + , "table data", obj.getType().getValue() + )); + } + } + + public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ + List fieldsList = restoreTableData.getFields(); +// System.err.println("fieldsList = " + String.join(",", fieldsList)); + if(fieldsList.size() == 0 ) { + ConsoleWriter.printlnRed(DBGitLang.getInstance() + .getValue("errors", "restore", "emptyFieldsList") + , 1 + ); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + return; + } + if (restoreTableData.getmapRows() == null) { + ConsoleWriter.printlnRed(DBGitLang.getInstance() + .getValue("errors", "restore", "emptyRowsList") + , 1 + ); + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + return; + } + + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + + MapDifference diffTableData = Maps.difference(restoreTableData.getmapRows(), currentTableData.getmapRows()); + try (StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql())) { + + String schema = getPhisicalSchema(restoreTableData.getTable().getSchema()); + String tblNameEscaped = adapter.escapeNameIfNeeded(schema) + "." + adapter.escapeNameIfNeeded(restoreTableData.getTable().getName()); + String fields = getFieldsPrefix(restoreTableData); + Map colTypes = getColumnDataTypes(restoreTableData.getMetaTable(), st); + Set keyNames = restoreTableData.getMetaTable().getFields().values().stream() + .filter(DBTableField::getIsPrimaryKey) + .map(DBTableField::getName) + .collect(Collectors.toSet()); + + //DELETE + if (!diffTableData.entriesOnlyOnRight().isEmpty()) { + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); + StringBuilder deleteQuery = new StringBuilder(); + + for (RowData rowData : diffTableData.entriesOnlyOnRight().values()) { + StringJoiner fieldJoiner = new StringJoiner(","); + StringJoiner valuejoiner = new StringJoiner(","); + + for( Map.Entry entry : rowData.getData(fieldsList).entrySet()) { + if (keyNames.contains(entry.getKey())) { + fieldJoiner.add("\"" + entry.getKey() + "\""); + valuejoiner.add(entry.getValue().convertToString()); + } + } + + String delFields = "(" + fieldJoiner.toString() + ")"; + String delValues = "(" + valuejoiner.toString() + ")"; + + if (delValues.length() > 2){ + final String ddl = MessageFormat.format( + "DELETE FROM {0} WHERE {1} = {2};", + tblNameEscaped, delFields, delValues + ); + deleteQuery.append(ddl).append("\n"); + ConsoleWriter.detailsPrintln(ddl, messageLevel + 1); + } + if (deleteQuery.length() > 50000) { + st.execute(deleteQuery.toString()); + deleteQuery = new StringBuilder(); + } + } + if (deleteQuery.length() > 1) { + st.execute(deleteQuery.toString()); + } + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + + //UPDATE + ConsoleWriter.detailsPrintln("Entries differing count: " + diffTableData.entriesDiffering().keySet().size(), messageLevel); + if (!diffTableData.entriesDiffering().isEmpty()) { + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "updating"), messageLevel); + String updateQuery = ""; + Map primarykeys = new HashMap(); + + for (ValueDifference diffRowData : diffTableData.entriesDiffering().values()) { + if (!diffRowData.leftValue().getHashRow().equals(diffRowData.rightValue().getHashRow())) { + + Map tempCols = diffRowData.leftValue().getData(fieldsList); + for (String key : tempCols.keySet()) { + if (tempCols.get(key) == null || tempCols.get(key).convertToString() == null) continue; + if (keyNames.contains(key)) { + primarykeys.put(key, tempCols.get(key).convertToString()); + tempCols.remove(key); + } + } + + + if (!tempCols.isEmpty()) { + StringJoiner keyFieldsJoiner = new StringJoiner(","); + StringJoiner keyValuesJoiner = new StringJoiner(","); + for (Map.Entry entry : primarykeys.entrySet()) { + keyFieldsJoiner.add("\"" + entry.getKey() + "\""); + keyValuesJoiner.add("\'" + entry.getValue() + "\'"); + } + primarykeys.clear(); + + + StringJoiner updFieldJoiner = new StringJoiner(","); + tempCols.forEach( (key, value) -> { + updFieldJoiner.add("\"" + key + "\""); + }); + + + updateQuery = "UPDATE " + tblNameEscaped + " SET (" + updFieldJoiner.toString() + ") = " + + valuesToString(tempCols.values(), colTypes, fieldsList) + " " + + "WHERE (" + keyFieldsJoiner.toString() + ") = (" + keyValuesJoiner.toString() + ");\n"; + + + ConsoleWriter.detailsPrintln(updateQuery, messageLevel); + st.execute(updateQuery); + updateQuery = ""; + } + + } + } + + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + if (updateQuery.length() > 1) { + ConsoleWriter.println(updateQuery, messageLevel); + st.execute(updateQuery); + } + } + + //INSERT + if (!diffTableData.entriesOnlyOnLeft().isEmpty()) { + ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "inserting"), messageLevel); + for (RowData rowData : diffTableData.entriesOnlyOnLeft().values()) { + + String insertQuery = MessageFormat.format("INSERT INTO {0}{1}{2};" + , tblNameEscaped, fields + , valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) + ); + + ConsoleWriter.detailsPrintln(insertQuery, messageLevel+1); + st.execute(insertQuery); + } + ConsoleWriter.detailsPrintln(lang.getValue("general", "ok"), messageLevel); + } + + } catch (Exception e) { + throw new ExceptionDBGitRestore(lang.getValue("errors", "restore", "objectRestoreError").withParams(restoreTableData.getTable().getSchema() + "." + restoreTableData.getTable().getName()) + , e + ); + } + } + + public String valuesToString(Collection datas, Map colTypes, List fieldsList) throws ExceptionDBGit, IOException { + String values="("; + StringJoiner joiner = new StringJoiner(","); + int i = 0; + for (ICellData data : datas) { + boolean isBoolean = ((colTypes.get(fieldsList.get(i)) != null) && (colTypes.get(fieldsList.get(i)).toLowerCase().contains("boolean"))); + + if (data instanceof TextFileData) { + if (((TextFileData) data).getFile() == null || ((TextFileData) data).getFile().getName().contains("null")) { + //TODO generalize this behaviour based on some parameter + //TODO nulls if nullable, '' if not + joiner.add("''"); + } else { + FileInputStream fis = new FileInputStream(((MapFileData) data).getFile()); + BufferedReader br = new BufferedReader(new InputStreamReader(fis)); + + StringBuilder sb = new StringBuilder(); + String line; + while(( line = br.readLine()) != null ) { + sb.append( line ); + sb.append( '\n' ); + } + br.close(); + + fis.close(); + String res = "'" + sb.toString().replace("'", "''") + .replace("\\", "\\\\") +// .replace("\n", "' || chr(10) || '") + .replace("\0", "' || '\\000' || '") + + "'"; + + if (res.endsWith(" || chr(10) || ''")) { + res = res.substring(0, res.length() - " || chr(10) || ''".length()); + } + joiner.add(res); + + + } + } else if (data instanceof MapFileData) { + if (((MapFileData) data).getFile() == null || ((MapFileData) data).getFile().getName().contains("null")) { + joiner.add("null"); + } else { + + FileInputStream fis = new FileInputStream(((MapFileData) data).getFile()); + + int byteRead; + StringBuilder sb = new StringBuilder(); + + while ((byteRead = fis.read()) != -1) { + String hex = Integer.toHexString(byteRead); + if (hex.length() == 1) hex = "0" + hex; + + sb.append(hex); + } + fis.close(); + joiner.add("decode('" + sb.toString() + "', 'hex')"); + + /* + joiner1.add("decode('" + sb.toString().replace("'", "''") + .replace("\\", "\\\\") + .replace("\n", "' || chr(10) || '") + .replace("\0", "' || '\\000' || '") + + "', 'escape')");*/ + } + } else if (data instanceof DateData) { + Date date = ((DateData) data).getDate(); + SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); + if (date != null) + joiner.add("TO_TIMESTAMP('" + format.format(date) + "', 'YYYYMMDDHH24MISS')"); + else + joiner.add("null"); + } else if (data instanceof BooleanData) { + if (((BooleanData) data).getValue() != null) + joiner.add(((BooleanData) data).getValue().toString()); + else + joiner.add("null"); + } else if (data instanceof LongData) { + String dt = data.getSQLData().replace("'", ""); + + if (isBoolean) { + if (dt == null || dt.equals("")) + joiner.add("null"); + else if (dt.equals("1")) + joiner.add("true"); + else + joiner.add("false"); + } else { + if (!dt.equals("")) + joiner.add(dt); + else + joiner.add("null"); + } + } else { + String dt = ((StringData) data).getValue(); + if (isBoolean) { + if (dt == null || dt.equals("")) + joiner.add("null"); + else if (dt.startsWith("t") || dt.startsWith("T") || dt.equals("1") || dt.startsWith("y") || dt.startsWith("Y")) + joiner.add("true"); + else + joiner.add("false"); + } else { + if (dt != null) + joiner.add("'" + dt.replace("'", "''") + "'"); + else + joiner.add("null"); + } + //joiner.add(data.getSQLData()); + + } + + //joiner.add("?"); + i++; + } + //ConsoleWriter.println("joiner: " + joiner1); + values+=joiner.toString()+")"; + return values; + } + + public String keysToString(Set keys) { + String fields=""; + if(keys.size()>1) { + String[] fieldsArray = keys.toArray(new String[keys.size()]); + fields="("+(fieldsArray[0].equals(fieldsArray[0].toLowerCase()) ? fieldsArray[0] : "\"" + fieldsArray[0] + "\""); + for(int i=1;i e.getValue().getOrder())) + .map(entry -> adapter.escapeNameIfNeeded(entry.getValue().getName())) + .collect(Collectors.joining(", ")) + ); + } + + private Map getColumnDataTypes(MetaTable tbl, StatementLogging st) throws SQLException { + HashMap colTypes = new HashMap(); + NameMeta nm = new NameMeta(tbl); + nm.setSchema(nm.getSchema()); + + ResultSet rsTypes = st.executeQuery(MessageFormat.format( + " select column_name, data_type from information_schema.columns \r\n" + + " where lower(table_schema) = lower(''{0}'') AND lower(table_name) = lower(''{1}'')" + , nm.getSchema(), nm.getName() + )); + + while (rsTypes.next()) { + colTypes.put(rsTypes.getString("column_name"), rsTypes.getString("data_type")); + } + return colTypes; + } + + +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java index 1ad23f6..9928fb6 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java @@ -18,7 +18,7 @@ import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitLinkPgAuto; import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemoteTestRepo; import ru.fusionsoft.dbgit.integration.primitives.chars.CommitsFromRepo; -import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LinesOf; +import ru.fusionsoft.dbgit.integration.primitives.chars.LinesOfUnsafeScalar; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckout; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitClonesRepo; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitRestore; @@ -105,7 +105,7 @@ public final void gitToFilesCheckoutWorks() { new PathAfterDbGitRun(new ArgsExplicit("checkout", "-ls", "-v"), path).toString(); }); System.out.println(consoleOutput); - return new LinesOf(consoleOutput) + return new LinesOfUnsafeScalar(consoleOutput) .list() .stream() .anyMatch(x -> x.contains(commitNameOfDs2)); @@ -180,9 +180,9 @@ public final void dbToFilesDumpWorks() { } ), new SimpleTest<>( - "'city' table data (small) is not empty", + "city table data (small) is not empty", (path) -> { - return ! Files.readAllLines(path.resolve(".dbgit/public/rental.csv")).isEmpty(); + return ! Files.readAllLines(path.resolve(".dbgit/public/city.csv")).isEmpty(); } ), new SimpleTest<>( diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java index 45c7370..da85706 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java @@ -1,14 +1,18 @@ package ru.fusionsoft.dbgit.integration; +import java.io.IOException; +import java.nio.file.Files; import java.nio.file.Path; import org.apache.commons.io.FileUtils; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import ru.fusionsoft.dbgit.integration.primitives.TestResult; +import ru.fusionsoft.dbgit.integration.primitives.files.AutoDeletingTempFilePath; import ru.fusionsoft.dbgit.integration.primitives.patch.PathPatchCreatingFile; import ru.fusionsoft.dbgit.integration.primitives.path.PathNotProjectRoot; import ru.fusionsoft.dbgit.integration.primitives.path.PathPatched; import ru.fusionsoft.dbgit.integration.primitives.path.PathPrintsToConsole; +import ru.fusionsoft.dbgit.integration.primitives.path.specific.CurrentWorkingDirectory; import ru.fusionsoft.dbgit.integration.primitives.path.specific.ProjectTestResourcesCleanDirectoryPath; import ru.fusionsoft.dbgit.integration.primitives.DescribedTestResult; import ru.fusionsoft.dbgit.integration.primitives.GroupedTestResult; @@ -191,4 +195,15 @@ public final void patchSequentalWorks() { } + @Test + public final void tempFileWorks() throws IOException { + Path path = new CurrentWorkingDirectory(); + try (AutoDeletingTempFilePath tempFilePath = new AutoDeletingTempFilePath(new CurrentWorkingDirectory(), "some")) { + path = tempFilePath; + final String data = "123"; + FileUtils.writeStringToFile(tempFilePath.toFile(), data); + Files.readAllLines(tempFilePath.toFile().toPath()).contains(data); + } + Assertions.assertFalse(path.toFile().exists()); + } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GroupedTestResult.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GroupedTestResult.java index 38836ec..19467e8 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GroupedTestResult.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/GroupedTestResult.java @@ -1,7 +1,7 @@ package ru.fusionsoft.dbgit.integration.primitives; import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LabelOfTestRunResult; -import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.LinesOfString; +import ru.fusionsoft.dbgit.integration.primitives.chars.LinesOfString; import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.ReportOfTestGroupRun; public class GroupedTestResult implements TestResult { @@ -14,10 +14,9 @@ public GroupedTestResult(CharSequence description, Subj subject, Test... t @Override public final boolean value() { - return new LinesOfString( - String.valueOf(this.text) - ).list().get(0) - .contains(new LabelOfTestRunResult(true)); + return String.valueOf( + new LinesOfString(String.valueOf(this.text)).list().get(0) + ).contains(new LabelOfTestRunResult(true)); } @Override diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyFunction.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyFunction.java index 0fe0651..73a181c 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyFunction.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/StickyFunction.java @@ -17,7 +17,9 @@ public StickyFunction(Function origin){ } public StickyFunction(Scalar origin){ - this((x) -> origin.value()); + this((x) -> { + return origin.value(); + }); } @Override diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java index 7c1cb09..09df2d2 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/args/ArgsRunningCommand.java @@ -1,15 +1,24 @@ package ru.fusionsoft.dbgit.integration.primitives.args; import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.Args; import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; -import ru.fusionsoft.dbgit.integration.primitives.path.PathRelativeTo; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfLines; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsWithBoundary; public class ArgsRunningCommand extends ArgsExplicit { public ArgsRunningCommand(CharSequence commandName) { super( - (System.getenv("ComSpec") == null) ? "sh" : System.getenv("ComSpec"), - (System.getenv("ComSpec") == null) ? "-c" : "/C", - commandName + ( System.getenv("ComSpec") == null ) + ? new CharSequence[]{commandName} + : new CharSequence[]{System.getenv("ComSpec"), "/C", commandName} + ); + } + public ArgsRunningCommand(Args commandRunArgs) { + super( + ( System.getenv("ComSpec") == null ) + ? new CharSequence[]{"sh", "-c", new CharsWithBoundary(new CharsOfLines(commandRunArgs), "\"")} + : new CharSequence[]{System.getenv("ComSpec"), "/C", new CharsOfLines(commandRunArgs)} ); } public ArgsRunningCommand(Path executablePath) { diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfConsoleWhenRunning.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfConsoleWhenRunning.java index 6007204..ca3a7d2 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfConsoleWhenRunning.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfConsoleWhenRunning.java @@ -12,13 +12,8 @@ public CharsOfConsoleWhenRunning(RunnableWithException runnable) { final PrintStream original = System.out; try (final ByteArrayOutputStream cachedOutputStream = new ByteArrayOutputStream();) { try { - - System.setOut(new PrintStream( - cachedOutputStream, - true, - "UTF-8" - )); - + System.setOut(new PrintStream(cachedOutputStream, true, "UTF-8")); + runnable.run(); return cachedOutputStream.toString(); @@ -34,11 +29,10 @@ public CharsOfConsoleWhenRunning(RunnableWithException runnable) { public static class CharsOfConsoleWhenRunningException extends Error { public CharsOfConsoleWhenRunningException(String text, Throwable cause) { super( - text.isEmpty() ? "" : "Execution broken after:\n"+text, - text.isEmpty() ? cause : cause.getCause() + (text.isEmpty() ? "Execution broken after:\n" : "") + text, + cause ); } - public CharsOfConsoleWhenRunningException(ByteArrayOutputStream byteArrayOutputStream, Throwable cause) { this(byteArrayOutputStream.toString(), cause); } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfLines.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfLines.java new file mode 100644 index 0000000..1287880 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsOfLines.java @@ -0,0 +1,38 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import ru.fusionsoft.dbgit.integration.primitives.Args; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalar; +import ru.fusionsoft.dbgit.integration.primitives.SafeScalarOf; + +public class CharsOfLines extends CharSequenceEnvelope { + public CharsOfLines(SafeScalar> charsListScalar, CharSequence delimiterChars, CharSequence itemPrefixChars) { + super(() -> { + return charsListScalar + .value() + .stream() + .map(x -> String.valueOf(itemPrefixChars) + x) + .collect(Collectors.joining(delimiterChars)); + } + ); + } + public CharsOfLines(Lines lines, CharSequence delimiterChars, CharSequence itemPrefixChars) { + this( new SafeScalarOf<>(lines::list), delimiterChars, itemPrefixChars ); + } + public CharsOfLines(List list, CharSequence delimiterChars, CharSequence itemPrefixChars) { + this( new SafeScalarOf<>(()->list), delimiterChars, itemPrefixChars); + } + public CharsOfLines(Args args, CharSequence delimiterChars, CharSequence itemPrefixChars) { + this( new SafeScalarOf<>(()-> Arrays.asList(args.values())), delimiterChars, itemPrefixChars); + } + public CharsOfLines(Args args) { + this( args, "\n", ""); + } + public CharsOfLines(Lines lines) { + this(lines, "\n", ""); + } + public CharsOfLines(List list) { + this(list, "\n", ""); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsWithBoundary.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsWithBoundary.java new file mode 100644 index 0000000..253b0c3 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/CharsWithBoundary.java @@ -0,0 +1,9 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.text.MessageFormat; + +public class CharsWithBoundary extends CharSequenceEnvelope { + public CharsWithBoundary(CharSequence origin, CharSequence boundaryChars) { + super(()-> MessageFormat.format("{1}{0}{1}", origin, boundaryChars)); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/Lines.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/Lines.java similarity index 56% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/Lines.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/Lines.java index de102f4..0f035f7 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/Lines.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/Lines.java @@ -1,4 +1,4 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; +package ru.fusionsoft.dbgit.integration.primitives.chars; import java.util.List; diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java index e87ee87..5a227b3 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesFromInputStream.java @@ -1,15 +1,14 @@ package ru.fusionsoft.dbgit.integration.primitives.chars; import java.io.BufferedReader; +import java.io.FileOutputStream; import java.io.InputStream; import java.io.InputStreamReader; -import java.util.Collections; +import java.io.PrintStream; import java.util.LinkedList; import java.util.List; -import java.util.stream.Collectors; import ru.fusionsoft.dbgit.integration.primitives.Scalar; import ru.fusionsoft.dbgit.integration.primitives.StickyScalar; -import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.Lines; public class LinesFromInputStream implements Lines { private final Scalar> listScalar; @@ -17,15 +16,13 @@ public LinesFromInputStream(InputStream origin, String codepageName) { this.listScalar = new StickyScalar<>( () -> { try ( - final BufferedReader reader = new BufferedReader( - codepageName.equals("default") - ? new InputStreamReader(origin) - : new InputStreamReader(origin, codepageName) - ) + final BufferedReader reader = new BufferedReader(new InputStreamReader(origin, codepageName)); ) { final LinkedList lines = new LinkedList<>(); String line; - while (( line = reader.readLine() ) != null) lines.add(line); + while (( line = reader.readLine() ) != null) { + lines.add(line); + } return lines; } } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOfString.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesOfString.java similarity index 72% rename from src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOfString.java rename to src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesOfString.java index 0b2d398..5bb1c0e 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOfString.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesOfString.java @@ -1,7 +1,8 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; +package ru.fusionsoft.dbgit.integration.primitives.chars; import java.util.Arrays; import java.util.List; +import ru.fusionsoft.dbgit.integration.primitives.chars.Lines; public class LinesOfString implements Lines { private final String string; diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesOfUnsafeScalar.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesOfUnsafeScalar.java new file mode 100644 index 0000000..3a9a3a3 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/LinesOfUnsafeScalar.java @@ -0,0 +1,18 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars; + +import java.util.Arrays; +import java.util.List; +import ru.fusionsoft.dbgit.integration.primitives.Scalar; + +public class LinesOfUnsafeScalar implements Lines { + private final Scalar charsScalar; + + public LinesOfUnsafeScalar(CharSequence charSequence) { + this.charsScalar = charSequence::toString; + } + + @Override + public final List list() throws Exception { + return Arrays.asList(String.valueOf(charsScalar.value()).split("\n")); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/CharsOfLines.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/CharsOfLines.java deleted file mode 100644 index 17a56e7..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/CharsOfLines.java +++ /dev/null @@ -1,21 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; -import java.util.List; -import java.util.stream.Collectors; -import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; - -public class CharsOfLines extends CharSequenceEnvelope { - public CharsOfLines(Lines lines, CharSequence linePrefix) { - super(() -> { - return lines.list().stream().map(x -> linePrefix + x).collect(Collectors.joining("\n")); - }); - } - public CharsOfLines(List list, CharSequence linePrefix) { - super(() -> { - return list.stream().map(x -> linePrefix + x).collect(Collectors.joining("\n")); - }); - } - - public CharsOfLines(Lines lines) { - this(lines, ""); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOf.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOf.java deleted file mode 100644 index 3e0d18b..0000000 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/LinesOf.java +++ /dev/null @@ -1,18 +0,0 @@ -package ru.fusionsoft.dbgit.integration.primitives.chars.specific.test; - -import java.util.Arrays; -import java.util.List; -import ru.fusionsoft.dbgit.integration.primitives.Scalar; - -public class LinesOf implements Lines { - private final Scalar stringScalar; - - public LinesOf(CharSequence charSequence) { - this.stringScalar = charSequence::toString; - } - - @Override - public final List list() throws Exception { - return Arrays.asList(stringScalar.value().split("\n")); - } -} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestFormat.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestFormat.java index cac00a0..53dd209 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestFormat.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestFormat.java @@ -2,16 +2,19 @@ import java.text.MessageFormat; import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfLines; +import ru.fusionsoft.dbgit.integration.primitives.chars.LinesOfUnsafeScalar; public class ReportOfTestFormat extends CharSequenceEnvelope { public ReportOfTestFormat(LabelOfTestRun label, CharSequence description, CharSequence subjectDetails, CharSequence testDetails) { super(() -> { final CharSequence subjectPart = String.valueOf(subjectDetails).trim().isEmpty() - ? "" - : "\n" + new CharsOfLines(new LinesOf(subjectDetails), "| "); + ? "" + : new CharsOfLines(new LinesOfUnsafeScalar(subjectDetails), "", "\n| "); + final CharSequence testPart = String.valueOf(testDetails).trim().isEmpty() - ? "" - : "\n" + new CharsOfLines(new LinesOf(testDetails), "| "); + ? "" + : new CharsOfLines(new LinesOfUnsafeScalar(testDetails), "", "\n| "); return MessageFormat.format( "{0} \"{1}\"{2}{3}" diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestGroupRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestGroupRun.java index 8463747..9601a7c 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestGroupRun.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestGroupRun.java @@ -28,14 +28,15 @@ public ReportOfTestGroupRun(CharSequence description, Subj subject, Test.. return new ReportOfTestFormat( new LabelOfTestRunResult(testResults.stream().allMatch(TestResult::value)), description, - new CharsOfLines(new LinesOf(subjectConsoleOutput), ""), - new CharsOfLines(testResults.stream().map(TestResult::text).collect(Collectors.toList()), "") + subjectConsoleOutput, + testResults.stream().map(TestResult::text).collect(Collectors.joining("\n")) ); } catch (CharsOfConsoleWhenRunning.CharsOfConsoleWhenRunningException e) { return new ReportOfTestFormat( new LabelOfTestRunBrokenSubject(), description, - "Thrown: " + ExceptionUtils.readStackTrace(e) + e.getMessage(), + ExceptionUtils.readStackTrace(e.getCause().getCause()) ); } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestRun.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestRun.java index abef103..53b44c4 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestRun.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/test/ReportOfTestRun.java @@ -2,8 +2,6 @@ import java.util.concurrent.atomic.AtomicBoolean; import org.junit.platform.commons.util.ExceptionUtils; -import ru.fusionsoft.dbgit.integration.primitives.SafeScalar; -import ru.fusionsoft.dbgit.integration.primitives.SafeScalarOf; import ru.fusionsoft.dbgit.integration.primitives.Test; import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; @@ -14,34 +12,35 @@ public class ReportOfTestRun extends CharSequenceEnvelope { public ReportOfTestRun(Subj subject, Test test) { super(() -> { return new CharsWithMaskedCredentials(new CharsOf(() -> { + try { final CharSequence subjDetails = String.valueOf(new CharsOfConsoleWhenRunning(subject::toString)); try { final AtomicBoolean value = new AtomicBoolean(false); final CharSequence testDetails = String.valueOf(new CharsOfConsoleWhenRunning(()-> value.set(test.value(subject)))); final LabelOfTestRun label = new LabelOfTestRunResult(value.get()); - return new ReportOfTestFormat(label, test.description(), subjDetails, testDetails); - - } catch (SafeScalarOf.SafeScalarError subjectThrowable) { return new ReportOfTestFormat( - new LabelOfTestRunBrokenSubject() - , test.description() - , ExceptionUtils.readStackTrace(subjectThrowable.getCause()) + label, + test.description(), + subjDetails, + testDetails ); } catch (Throwable testThrowable) { return new ReportOfTestFormat( - new LabelOfTestRunExceptional() - , test.description() - , ExceptionUtils.readStackTrace(testThrowable) + new LabelOfTestRunExceptional(), + test.description(), + ExceptionUtils.readStackTrace(testThrowable) ); } - } catch (CharsOfConsoleWhenRunning.CharsOfConsoleWhenRunningException subjectThrowable) { + } catch (CharsOfConsoleWhenRunning.CharsOfConsoleWhenRunningException e) { return new ReportOfTestFormat( - new LabelOfTestRunBrokenSubject() - , test.description() - , ExceptionUtils.readStackTrace(subjectThrowable) + new LabelOfTestRunBrokenSubject(), + test.description(), + e.getMessage(), + ExceptionUtils.readStackTrace(e.getCause().getCause()) ); } + })); }); } diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/AutoDeletingTempFilePath.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/AutoDeletingTempFilePath.java new file mode 100644 index 0000000..9fabb1d --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/files/AutoDeletingTempFilePath.java @@ -0,0 +1,33 @@ +package ru.fusionsoft.dbgit.integration.primitives.files; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Random; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; +import ru.fusionsoft.dbgit.integration.primitives.path.PathEnvelope; + +public class AutoDeletingTempFilePath extends PathEnvelope implements AutoCloseable { + + public AutoDeletingTempFilePath(CharSequence fileName) { + super(()-> Paths.get(String.valueOf(fileName))); + } + public AutoDeletingTempFilePath(Path directory, CharSequence prefix) { + this( + new CharsOf<>( ()-> { + return directory.resolve( + prefix + + String.format("#%06x", new Random().nextInt(256 * 256 * 256)) + ) + .toAbsolutePath() + .toString(); + }) + ); + } + + @Override + public final void close() throws IOException { + Files.deleteIfExists(this.toFile().toPath()); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java index 12cd441..7dc91fa 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/PathPatchRunningProcessFrom.java @@ -1,16 +1,18 @@ package ru.fusionsoft.dbgit.integration.primitives.patch; -import java.io.ByteArrayOutputStream; import java.io.PrintStream; +import java.nio.file.Files; import java.nio.file.Path; import java.text.MessageFormat; import java.util.Arrays; +import java.util.List; import java.util.function.Consumer; import java.util.stream.Collectors; import ru.fusionsoft.dbgit.integration.primitives.Args; import ru.fusionsoft.dbgit.integration.primitives.Patch; -import ru.fusionsoft.dbgit.integration.primitives.chars.LinesFromInputStream; -import ru.fusionsoft.dbgit.integration.primitives.chars.specific.test.CharsOfLines; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOf; +import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfLines; +import ru.fusionsoft.dbgit.integration.primitives.files.AutoDeletingTempFilePath; public class PathPatchRunningProcessFrom implements Patch { @@ -23,65 +25,47 @@ public PathPatchRunningProcessFrom(Args processRunCommandLine, PrintStream print } @Override - public final void apply(Path root) throws Exception { + public final void apply(Path workingDirectory) throws Exception { + final Consumer outputConsumer = printStream::println; + outputConsumer.accept(MessageFormat.format( + "{0} # {1}", + workingDirectory.toString(), + String.join(" ", processRunCommandLine.values()) + )); + try ( - final ByteArrayOutputStream cachedOutputStream = new ByteArrayOutputStream(); - final PrintStream cachedPrintStream = new PrintStream( - cachedOutputStream, - true, - "UTF-8" - ) + final AutoDeletingTempFilePath tempOutPath = new AutoDeletingTempFilePath(workingDirectory.resolve("../"), "out"); + final AutoDeletingTempFilePath tempErrPath = new AutoDeletingTempFilePath(workingDirectory.resolve("../"), "err"); ) { - final Consumer outputConsumer = (chars) -> { - cachedPrintStream.println(chars); - printStream.println(chars); - }; - - outputConsumer.accept(MessageFormat.format( - "{0} # {1}", - root.toString(), - String.join( - " ", - processRunCommandLine.values() - ) - )); - final Process process = new ProcessBuilder() - .directory(root.toAbsolutePath().toFile()) + .directory(workingDirectory.toFile()) .command( Arrays.stream(processRunCommandLine.values()) .map(String::valueOf) .collect(Collectors.toList()) ) + .redirectOutput(tempOutPath.toFile()) + .redirectError(tempErrPath.toFile()) .start(); process.getOutputStream().close(); - - final CharSequence processOutput = new CharsOfLines( - new LinesFromInputStream(process.getInputStream(), "Utf-8"), "> " - ).toString(); - final CharSequence processErrOutput = new CharsOfLines( - new LinesFromInputStream(process.getErrorStream(), "Utf-8"), "> " - ).toString(); - + final int exitCode = process.waitFor(); - process.destroyForcibly(); - outputConsumer.accept(processOutput); - + outputConsumer.accept(new CharsOfLines(Files.readAllLines(tempOutPath.toFile().toPath()), "\n", "> ")); + if (exitCode != 0) { throw new Exception(MessageFormat.format( - "Process exited with error, code {0}" - + "\nErrors: {1}" -// + "\nOriginal output: {2}" - , exitCode - , processErrOutput.length() != 0 - ? "\n" + processErrOutput - : "...error stream was empty" -// ,cachedOutputStream.size() != 0 -// ? "\n" + cachedOutputStream.toString() -// : "...output stream was empty" + "Process exited with error, code {0}\nErrors: {1}", + exitCode, + new CharsOf<>(()->{ + final List lines = Files.readAllLines(tempErrPath.toFile().toPath()); + return lines.isEmpty() + ? "...error stream was empty" + : new CharsOfLines(lines, "", "\n> "); + }) )); } + } } } From 44c3aca4516ca809b0a74d3978cc34d270e1553f Mon Sep 17 00:00:00 2001 From: rocket-3 <47713503+rocket-3@users.noreply.github.com> Date: Sun, 30 May 2021 16:50:35 +0300 Subject: [PATCH 57/68] Update .rultor.yml Suppress mvn install package command output --- .rultor.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index e0464c1..e0cc173 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -7,13 +7,13 @@ merge: script: |- java -version --batch-mode mvn -version --batch-mode - mvn clean install package appassembler:assemble -D skipTests --batch-mode + mvn clean install package appassembler:assemble -D skipTests --batch-mode --quiet chmod u+r+x target/dbgit/bin/dbgit mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode deploy: script: |- java -version --batch-mode mvn -version --batch-mode - mvn clean install package appassembler:assemble -D skipTests --batch-mode + mvn clean install package appassembler:assemble -D skipTests --batch-mode --quiet chmod u+r+x target/dbgit/bin/dbgit mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode From 425c4512534016090b066f1d38039776217fad4c Mon Sep 17 00:00:00 2001 From: rocket-3 <47713503+rocket-3@users.noreply.github.com> Date: Mon, 31 May 2021 19:11:07 +0300 Subject: [PATCH 58/68] Update rultor.yml for brevity, also try using custom args for tests running --- .rultor.yml | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index e0cc173..8cb47c9 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -3,17 +3,15 @@ env: assets: pgSecret.txt: rocket-3/dbgit-test#pgSecret.txt gitSecret.txt: rocket-3/dbgit-test#gitSecret.txt -merge: +install: script: |- java -version --batch-mode mvn -version --batch-mode mvn clean install package appassembler:assemble -D skipTests --batch-mode --quiet chmod u+r+x target/dbgit/bin/dbgit +merge: + script: |- mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode deploy: script: |- - java -version --batch-mode - mvn -version --batch-mode - mvn clean install package appassembler:assemble -D skipTests --batch-mode --quiet - chmod u+r+x target/dbgit/bin/dbgit - mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode + mvn test -Dtest=$tests --batch-mode From 73acda59eec4341af81abeaddfc8e71d5a146f85 Mon Sep 17 00:00:00 2001 From: rocket-3 <47713503+rocket-3@users.noreply.github.com> Date: Mon, 31 May 2021 19:19:44 +0300 Subject: [PATCH 59/68] Update .rultor.yml --- .rultor.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index 8cb47c9..262a005 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -3,8 +3,7 @@ env: assets: pgSecret.txt: rocket-3/dbgit-test#pgSecret.txt gitSecret.txt: rocket-3/dbgit-test#gitSecret.txt -install: - script: |- +install: |- java -version --batch-mode mvn -version --batch-mode mvn clean install package appassembler:assemble -D skipTests --batch-mode --quiet From 3e6669b1629b39d730f6aaf32361943e2b643683 Mon Sep 17 00:00:00 2001 From: rocket-3 <47713503+rocket-3@users.noreply.github.com> Date: Thu, 3 Jun 2021 22:46:57 +0300 Subject: [PATCH 60/68] Update rultor.yml with `tests` parameter being optional --- .rultor.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index 262a005..5cfaf6e 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -10,7 +10,7 @@ install: |- chmod u+r+x target/dbgit/bin/dbgit merge: script: |- - mvn test -Dtest=*selfTest,*DbGitIntegrationTestBasic* --batch-mode + mvn test -Dtest=${tests:-'*selfTest,*DbGitIntegrationTestBasic*'}$ --batch-mode deploy: script: |- - mvn test -Dtest=$tests --batch-mode + mvn test -Dtest=${tests:-'*selfTest,*DbGitIntegrationTestBasic*'}$ --batch-mode From 1911a448ffa3425b33a6a9de9d457dfe0bd63cb7 Mon Sep 17 00:00:00 2001 From: rocket-3 <47713503+rocket-3@users.noreply.github.com> Date: Fri, 4 Jun 2021 00:34:10 +0300 Subject: [PATCH 61/68] Update .rultor.yml to fix my mistake with extra symbol in cmdline --- .rultor.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.rultor.yml b/.rultor.yml index 5cfaf6e..54df89d 100644 --- a/.rultor.yml +++ b/.rultor.yml @@ -10,7 +10,7 @@ install: |- chmod u+r+x target/dbgit/bin/dbgit merge: script: |- - mvn test -Dtest=${tests:-'*selfTest,*DbGitIntegrationTestBasic*'}$ --batch-mode + mvn test -Dtest=${tests:-'*selfTest,*DbGitIntegrationTestBasic*'} --batch-mode deploy: script: |- - mvn test -Dtest=${tests:-'*selfTest,*DbGitIntegrationTestBasic*'}$ --batch-mode + mvn test -Dtest=${tests:-'*selfTest,*DbGitIntegrationTestBasic*'} --batch-mode From f1e2c90f2b9c2984fbb6de0ccab044e931627719 Mon Sep 17 00:00:00 2001 From: rocket Date: Wed, 2 Jun 2021 19:34:27 +0300 Subject: [PATCH 62/68] Fix restore table data on postgres when DBGit can't handle changed column order between schema generations on delete Fix restore table data on postgres when DBGit can't handle text id columns on delete Fix DbGitIntegrationTestBasic#gitToDbRestoreWorks when it can't checkout to other commit because of changed .dblink file conflict --- .../fusionsoft/dbgit/data_table/RowData.java | 384 +++++++++--------- .../fusionsoft/dbgit/meta/MetaTableData.java | 6 +- .../postgres/DBRestoreTableDataPostgres.java | 39 +- .../DbGitIntegrationTestBasic.java | 5 +- .../specific/PathPatchDbGitCheckoutHard.java | 22 + 5 files changed, 253 insertions(+), 203 deletions(-) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckoutHard.java diff --git a/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java b/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java index abf313e..a3e58f7 100644 --- a/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java +++ b/src/main/java/ru/fusionsoft/dbgit/data_table/RowData.java @@ -1,190 +1,194 @@ -package ru.fusionsoft.dbgit.data_table; - -import java.io.IOException; -import java.sql.ResultSet; -import java.util.*; - -import de.siegmar.fastcsv.reader.CsvRow; -import org.apache.commons.csv.CSVPrinter; -import org.apache.commons.csv.CSVRecord; - -import ru.fusionsoft.dbgit.core.DBGitLang; -import ru.fusionsoft.dbgit.core.ExceptionDBGit; -import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; -import ru.fusionsoft.dbgit.dbobjects.DBTable; -import ru.fusionsoft.dbgit.meta.MetaTable; -import ru.fusionsoft.dbgit.utils.CalcHash; -import ru.fusionsoft.dbgit.utils.ConsoleWriter; - -public class RowData { - //protected Map data = new LinkedHashMap<>(); - private List rowList = new ArrayList<>(); - private String hashRow; - //protected String key; - //protected MetaTable metaTable; - - public RowData(ResultSet rs, MetaTable metaTable) throws Exception { - //this.metaTable = metaTable; - loadDataFromRS(rs, metaTable); - } - - public RowData(CsvRow record, MetaTable metaTable, CsvRow titleColumns) throws Exception { - //this.metaTable = metaTable; - loadDataFromCSVRecord(record, titleColumns, metaTable); - } - - public RowData(CSVRecord record, MetaTable metaTable, CSVRecord titleColumns) throws Exception { - //this.metaTable = metaTable; - loadDataFromCSVRecord(record, titleColumns, metaTable); - } - - public void loadDataFromRS(ResultSet rs, MetaTable metaTable) throws Exception { - for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) { - String columnName = rs.getMetaData().getColumnName(i+1); - - if (columnName.equalsIgnoreCase("DBGIT_ROW_NUM")) - continue; - - ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); - - if (cd.loadFromDB(rs, rs.getMetaData().getColumnName(i+1))) - rowList.add(cd); - //data.put(columnName, cd); - } - - hashRow = calcRowHash().substring(0, 24); - - //key = calcRowKey(metaTable.getIdColumns()); - } - - private void loadDataFromCSVRecord(CsvRow record, CsvRow titleColumns, MetaTable metaTable) throws Exception { - if (record.getFieldCount() != titleColumns.getFieldCount()) { - throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "dataTable", "differentCount")); - } - - for (int i = 0; i < record.getFieldCount(); i++) { - String columnName = titleColumns.getField(i); - if (metaTable.getFieldsMap().get(columnName) == null) { - throw new ExceptionDBGitRunTime(DBGitLang.getInstance().getValue("errors", "dataTable", "fieldNotFound").withParams(columnName)); - } - - ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); - cd.deserialize(record.getField(i).equals("") ? null : record.getField(i)); - - rowList.add(cd); - //data.put(columnName, cd); - } - hashRow = calcRowHash().substring(0, 24); - - //key = calcRowKey(metaTable.getIdColumns()); - - } - - private void loadDataFromCSVRecord(CSVRecord record, CSVRecord titleColumns, MetaTable metaTable) throws Exception { - - if (record.size() != titleColumns.size()) { - throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "dataTable", "differentCount")); - } - - for (int i = 0; i < record.size(); i++) { - String columnName = titleColumns.get(i); - if (metaTable.getFieldsMap().get(columnName) == null) { - throw new ExceptionDBGitRunTime(DBGitLang.getInstance().getValue("errors", "dataTable", "fieldNotFound").withParams(columnName)); - } - - ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); - cd.deserialize(record.get(i)); - - rowList.add(cd); - //data.put(columnName, cd); - } - hashRow = calcRowHash().substring(0, 24); - - //key = calcRowKey(metaTable.getIdColumns()); - } - - public void saveDataToCsv(CSVPrinter csvPrinter, DBTable tbl) throws Exception { - //for (ICellData cd : getData().values()) - for (ICellData cd : rowList) - csvPrinter.print(cd.serialize(tbl)); - - csvPrinter.println(); - } - /* - public String calcRowKey(List idColumns) throws Exception { - if (idColumns.size() > 0) { - StringBuilder keyBuilder = new StringBuilder(); - for (String nmId : idColumns) { - keyBuilder.append(data.get(nmId).convertToString()+"_"); - } - return keyBuilder.toString(); - } else { - return hashRow; - } - } - */ - public String calcRowKey(List idColumns) throws Exception { - return hashRow; - /* - if (idColumns.size() > 0) { - StringBuilder keyBuilder = new StringBuilder(); - for (Integer nmId : idColumns) { - keyBuilder.append(rowList.get(nmId).convertToString()+"_"); - } - return keyBuilder.toString(); - } else { - return hashRow; - }*/ - } - - - public String calcRowHash() throws Exception { - CalcHash ch = new CalcHash(); - //for (ICellData cd : data.values()) { - for (ICellData cd : rowList) { - String str = cd.convertToString(); - if ( str != null) - ch.addData(str); - } - return ch.calcHashStr(); - } - - public Map getData(List fields) { - Map res = new LinkedHashMap<>(); - - int i = 0; - for (ICellData cd : rowList) { - res.put(fields.get(i), cd); - i++; - } - - return res; - } - - public Map getData() { - Map res = new HashMap<>(); - - int i = 0; - for (ICellData cd : rowList) { - res.put(String.valueOf(i), cd); - i++; - } - - return res; - } - - public List getListData() { - return rowList; - } - - public String getHashRow() { - return hashRow; - } - - public String getKey() { - //return key; - return hashRow; - } - - -} +package ru.fusionsoft.dbgit.data_table; + +import java.sql.ResultSet; +import java.text.MessageFormat; +import java.util.*; + +import de.siegmar.fastcsv.reader.CsvRow; +import java.util.stream.Collectors; + +import org.apache.commons.csv.CSVPrinter; +import org.apache.commons.csv.CSVRecord; + +import ru.fusionsoft.dbgit.core.DBGitLang; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRunTime; +import ru.fusionsoft.dbgit.dbobjects.DBTable; +import ru.fusionsoft.dbgit.meta.MetaTable; +import ru.fusionsoft.dbgit.utils.CalcHash; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; + +public class RowData { + //protected Map data = new LinkedHashMap<>(); + private List rowList = new ArrayList<>(); + private String hashRow; + //protected String key; + //protected MetaTable metaTable; + + public RowData(ResultSet rs, MetaTable metaTable) throws Exception { + //this.metaTable = metaTable; + loadDataFromRS(rs, metaTable); + } + + public RowData(CsvRow record, MetaTable metaTable, CsvRow titleColumns) throws Exception { + //this.metaTable = metaTable; + loadDataFromCSVRecord(record, titleColumns, metaTable); + } + + @Deprecated + public RowData(CSVRecord record, MetaTable metaTable, CSVRecord titleColumns) throws Exception { + //this.metaTable = metaTable; + loadDataFromCSVRecord(record, titleColumns, metaTable); + } + + private void loadDataFromRS(ResultSet rs, MetaTable metaTable) throws Exception { + for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) { + String columnName = rs.getMetaData().getColumnName(i+1); + + if (columnName.equalsIgnoreCase("DBGIT_ROW_NUM")) + continue; + + ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); + + if (cd.loadFromDB(rs, rs.getMetaData().getColumnName(i+1))) + rowList.add(cd); + //data.put(columnName, cd); + } + + hashRow = calcRowHash().substring(0, 24); + + //key = calcRowKey(metaTable.getIdColumns()); + } + + private void loadDataFromCSVRecord(CsvRow record, CsvRow titleColumns, MetaTable metaTable) throws Exception { + if (record.getFieldCount() != titleColumns.getFieldCount()) { + throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "dataTable", "differentCount")); + } + + for (int i = 0; i < record.getFieldCount(); i++) { + String columnName = titleColumns.getField(i); + if (metaTable.getFieldsMap().get(columnName) == null) { + throw new ExceptionDBGitRunTime(DBGitLang.getInstance().getValue("errors", "dataTable", "fieldNotFound").withParams(columnName)); + } + + ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); + cd.deserialize(record.getField(i).equals("") ? null : record.getField(i)); + + rowList.add(cd); + //data.put(columnName, cd); + } + hashRow = calcRowHash().substring(0, 24); + + //key = calcRowKey(metaTable.getIdColumns()); + + } + + @Deprecated + private void loadDataFromCSVRecord(CSVRecord record, CSVRecord titleColumns, MetaTable metaTable) throws Exception { + + if (record.size() != titleColumns.size()) { + throw new ExceptionDBGit(DBGitLang.getInstance().getValue("errors", "dataTable", "differentCount")); + } + + for (int i = 0; i < record.size(); i++) { + String columnName = titleColumns.get(i); + if (metaTable.getFieldsMap().get(columnName) == null) { + throw new ExceptionDBGitRunTime(DBGitLang.getInstance().getValue("errors", "dataTable", "fieldNotFound").withParams(columnName)); + } + + ICellData cd = FactoryCellData.createCellData(metaTable.getFieldsMap().get(columnName).getTypeUniversal()); + cd.deserialize(record.get(i)); + + rowList.add(cd); + //data.put(columnName, cd); + } + hashRow = calcRowHash().substring(0, 24); + + //key = calcRowKey(metaTable.getIdColumns()); + } + + public void saveDataToCsv(CSVPrinter csvPrinter, DBTable tbl) throws Exception { + //for (ICellData cd : getData().values()) + for (ICellData cd : rowList) + csvPrinter.print(cd.serialize(tbl)); + + csvPrinter.println(); + } + /* + public String calcRowKey(List idColumns) throws Exception { + if (idColumns.size() > 0) { + StringBuilder keyBuilder = new StringBuilder(); + for (String nmId : idColumns) { + keyBuilder.append(data.get(nmId).convertToString()+"_"); + } + return keyBuilder.toString(); + } else { + return hashRow; + } + } + */ + public String calcRowKey(List idColumns) throws Exception { + return hashRow; + /* + if (idColumns.size() > 0) { + StringBuilder keyBuilder = new StringBuilder(); + for (Integer nmId : idColumns) { + keyBuilder.append(rowList.get(nmId).convertToString()+"_"); + } + return keyBuilder.toString(); + } else { + return hashRow; + }*/ + } + + + public String calcRowHash() throws Exception { + CalcHash ch = new CalcHash(); + //for (ICellData cd : data.values()) { + for (ICellData cd : rowList) { + String str = cd.convertToString(); + if ( str != null) + ch.addData(str); + } + return ch.calcHashStr(); + } + + public Map getData(List fields) { + Map res = new LinkedHashMap<>(); + + int i = 0; + for (ICellData cd : rowList) { + res.put(fields.get(i), cd); + i++; + } + + return res; + } + + public Map getData() { + Map res = new HashMap<>(); + + int i = 0; + for (ICellData cd : rowList) { + res.put(String.valueOf(i), cd); + i++; + } + + return res; + } + + public List getListData() { + return rowList; + } + + public String getHashRow() { + return hashRow; + } + + public String getKey() { + //return key; + return hashRow; + } + + +} diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java index f547312..fa3042d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaTableData.java @@ -88,8 +88,10 @@ public void setTable(DBTable table) throws ExceptionDBGit { this.table = table; setName(table.getSchema()+"/"+table.getName()+"."+getType().getValue()); } - - + + public void setFields(List fields) { + this.fields = fields; + } @Override public void setName(String name) throws ExceptionDBGit { diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index a303494..c5320e3 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -77,6 +77,13 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { if (getAdapter().getTable(schema, currentTableData.getTable().getName()) != null) { //actually load data from database currentTableData.setDataTable(getAdapter().getTableData(schema, currentTableData.getTable().getName())); + currentTableData.setFields( + getAdapter().getTableFields(schema, currentTableData.getTable().getName()) + .entrySet().stream() + .sorted(Comparator.comparing(x->x.getValue().getOrder())) + .map( x->x.getKey() ) + .collect(Collectors.toList()) + ); ResultSet rs = currentTableData.getDataTable().resultSet(); @@ -127,9 +134,7 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ - List fieldsList = restoreTableData.getFields(); -// System.err.println("fieldsList = " + String.join(",", fieldsList)); - if(fieldsList.size() == 0 ) { + if(restoreTableData.getFields().size() == 0 || currentTableData.getFields().size() == 0 ) { ConsoleWriter.printlnRed(DBGitLang.getInstance() .getValue("errors", "restore", "emptyFieldsList") , 1 @@ -163,6 +168,18 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa //DELETE if (!diffTableData.entriesOnlyOnRight().isEmpty()) { + diffTableData.entriesOnlyOnRight().values().forEach( x->{ + System.err.print( + MessageFormat.format( + "\n{0}", + x.getData(currentTableData.getFields()) + .entrySet() + .stream() + .map(y -> y.getKey() + " = " + y.getValue().getSQLData().substring(0, Integer.min(y.getValue().getSQLData().length(), 8))) + .collect(Collectors.joining("\t")) + ) + ); + }); ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); StringBuilder deleteQuery = new StringBuilder(); @@ -170,10 +187,15 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa StringJoiner fieldJoiner = new StringJoiner(","); StringJoiner valuejoiner = new StringJoiner(","); - for( Map.Entry entry : rowData.getData(fieldsList).entrySet()) { + for( Map.Entry entry : rowData.getData(currentTableData.getFields()).entrySet()) { if (keyNames.contains(entry.getKey())) { fieldJoiner.add("\"" + entry.getKey() + "\""); - valuejoiner.add(entry.getValue().convertToString()); + final String value = entry.getValue().convertToString(); + if( value.matches("-?\\d+(\\.0)?") ) { + valuejoiner.add( String.valueOf( (long) Double.parseDouble(value) ) ); + } else { + valuejoiner.add("'" + value + "'"); + } } } @@ -200,7 +222,6 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa } //UPDATE - ConsoleWriter.detailsPrintln("Entries differing count: " + diffTableData.entriesDiffering().keySet().size(), messageLevel); if (!diffTableData.entriesDiffering().isEmpty()) { ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "updating"), messageLevel); String updateQuery = ""; @@ -209,7 +230,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa for (ValueDifference diffRowData : diffTableData.entriesDiffering().values()) { if (!diffRowData.leftValue().getHashRow().equals(diffRowData.rightValue().getHashRow())) { - Map tempCols = diffRowData.leftValue().getData(fieldsList); + Map tempCols = diffRowData.leftValue().getData(restoreTableData.getFields()); for (String key : tempCols.keySet()) { if (tempCols.get(key) == null || tempCols.get(key).convertToString() == null) continue; if (keyNames.contains(key)) { @@ -236,7 +257,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa updateQuery = "UPDATE " + tblNameEscaped + " SET (" + updFieldJoiner.toString() + ") = " - + valuesToString(tempCols.values(), colTypes, fieldsList) + " " + + valuesToString(tempCols.values(), colTypes, restoreTableData.getFields()) + " " + "WHERE (" + keyFieldsJoiner.toString() + ") = (" + keyValuesJoiner.toString() + ");\n"; @@ -262,7 +283,7 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa String insertQuery = MessageFormat.format("INSERT INTO {0}{1}{2};" , tblNameEscaped, fields - , valuesToString(rowData.getData(fieldsList).values(), colTypes, fieldsList) + , valuesToString(rowData.getData(restoreTableData.getFields()).values(), colTypes, restoreTableData.getFields()) ); ConsoleWriter.detailsPrintln(insertQuery, messageLevel+1); diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java index 9928fb6..568ef29 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java @@ -20,6 +20,7 @@ import ru.fusionsoft.dbgit.integration.primitives.chars.CommitsFromRepo; import ru.fusionsoft.dbgit.integration.primitives.chars.LinesOfUnsafeScalar; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckout; +import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckoutHard; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitClonesRepo; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitRestore; import ru.fusionsoft.dbgit.integration.primitives.chars.CharsOfConsoleWhenRunning; @@ -252,10 +253,10 @@ public final void gitToDbRestoreWorks() throws Exception { new PathPatchDbGitCheckout(commitNames.get(0), "-nodb", "-v"), new PathPatchDbGitLink(linkArgs), new PathPatchDbGitRestore("-r", "-v"), - new PathPatchDbGitCheckout(commitNames.get(1), "-nodb", "-v"), + new PathPatchDbGitCheckoutHard(commitNames.get(1), "-nodb", "-v"), new PathPatchDbGitLink(linkArgs), new PathPatchDbGitRestore("-r", "-v"), - new PathPatchDbGitCheckout(commitNames.get(2), "-nodb", "-v"), + new PathPatchDbGitCheckoutHard(commitNames.get(2), "-nodb", "-v"), new PathPatchDbGitLink(linkArgs), new PathPatchDbGitRestore("-r", "-v") ), diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckoutHard.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckoutHard.java new file mode 100644 index 0000000..502985a --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/patch/specific/PathPatchDbGitCheckoutHard.java @@ -0,0 +1,22 @@ +package ru.fusionsoft.dbgit.integration.primitives.patch.specific; + +import java.io.PrintStream; +import java.nio.file.Path; +import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; +import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitCheckout; + +public class PathPatchDbGitCheckoutHard extends PatchSequential { + public PathPatchDbGitCheckoutHard(ArgsDbGitCheckout argsDbGitCheckout, PrintStream printStream) { + super( + new PathPatchDbGitReset("-hard"), + new PathPatchDbGitCheckout(argsDbGitCheckout, printStream) + ); + } + + public PathPatchDbGitCheckoutHard(CharSequence... checkoutArgs) { + super( + new PathPatchDbGitReset("-hard"), + new PathPatchDbGitCheckout(new ArgsDbGitCheckout(checkoutArgs)) + ); + } +} From 907392074a04a48357a3882a229a5a7f4957c664 Mon Sep 17 00:00:00 2001 From: rocket Date: Thu, 3 Jun 2021 21:02:42 +0300 Subject: [PATCH 63/68] Fix of DbGit can not restore table data for Postgres when new vesion of table contains no rows Some new exception throwing points added to catch possible issues in future Change DBGitIntegrationTestBasic case when DBGit can't handle data with 10k+ rows table - now passes when file is empty, cause it's 'not a bug but a feature' now --- .../fusionsoft/dbgit/command/CmdRestore.java | 5 +-- .../ru/fusionsoft/dbgit/core/DBGitIndex.java | 3 +- .../postgres/DBRestoreTableDataPostgres.java | 31 ++++--------------- src/main/resources/lang/eng.yaml | 2 +- .../DbGitIntegrationTestBasic.java | 4 +-- 5 files changed, 13 insertions(+), 32 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java index 513578e..07eb480 100644 --- a/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java +++ b/src/main/java/ru/fusionsoft/dbgit/command/CmdRestore.java @@ -210,8 +210,9 @@ private boolean checkNeedsRestore(IMetaObject obj){ final boolean exists = GitMetaDataManager.getInstance().loadFromDB(dbObj); isRestore = !exists || !dbObj.getHash().equals(obj.getHash()); } catch (ExceptionDBGit e) { - isRestore = true; - e.printStackTrace(); + throw new ExceptionDBGitRunTime(e); +// isRestore = true; +// e.printStackTrace(); } return isRestore; } diff --git a/src/main/java/ru/fusionsoft/dbgit/core/DBGitIndex.java b/src/main/java/ru/fusionsoft/dbgit/core/DBGitIndex.java index cbabb81..735eff8 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/DBGitIndex.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/DBGitIndex.java @@ -77,8 +77,7 @@ public boolean removeItem(String name) { saveDBIndex(); return true; } catch (Exception ex){ - ex.printStackTrace(); - return false; + throw new ExceptionDBGitRunTime("Remove item from index error", ex); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java index c5320e3..4b5da5c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTableDataPostgres.java @@ -134,21 +134,14 @@ public boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { } public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableData currentTableData) throws Exception{ - if(restoreTableData.getFields().size() == 0 || currentTableData.getFields().size() == 0 ) { - ConsoleWriter.printlnRed(DBGitLang.getInstance() - .getValue("errors", "restore", "emptyFieldsList") - , 1 - ); - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - return; + //if empty restore table data -> delete all currentTableData + if (currentTableData.getFields().size() == 0 ) { + final CharSequence msg = DBGitLang.getInstance().getValue("errors", "restore", "currentFieldsListIsEmpty").toString(); + throw new ExceptionDBGit(msg); } if (restoreTableData.getmapRows() == null) { - ConsoleWriter.printlnRed(DBGitLang.getInstance() - .getValue("errors", "restore", "emptyRowsList") - , 1 - ); - ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); - return; + final CharSequence msg = DBGitLang.getInstance().getValue("errors", "restore", "emptyRowsList").toString(); + throw new ExceptionDBGit(msg); } IDBAdapter adapter = getAdapter(); @@ -168,18 +161,6 @@ public void restoreTableDataPostgres(MetaTableData restoreTableData, MetaTableDa //DELETE if (!diffTableData.entriesOnlyOnRight().isEmpty()) { - diffTableData.entriesOnlyOnRight().values().forEach( x->{ - System.err.print( - MessageFormat.format( - "\n{0}", - x.getData(currentTableData.getFields()) - .entrySet() - .stream() - .map(y -> y.getKey() + " = " + y.getValue().getSQLData().substring(0, Integer.min(y.getValue().getSQLData().length(), 8))) - .collect(Collectors.joining("\t")) - ) - ); - }); ConsoleWriter.detailsPrintln(lang.getValue("general", "restore", "deleting"), messageLevel); StringBuilder deleteQuery = new StringBuilder(); diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index d7e0f72..941d303 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -203,7 +203,7 @@ errors: cantConnect: Can't connect to db! errorLoadDelete: Error load and delete object fileAlreadyExists: Error write script, file {0} already exists - emptyFieldsList: Empty fieldList, maybe empty csv... + currentFieldsListIsEmpty: Empty fieldList in current table which means the table is not reconstructed properly... emptyRowsList: MapRows is null, maybe empty csv... add: badCommand: Bad command. Not found object to add! diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java index 568ef29..780b12d 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java @@ -187,9 +187,9 @@ public final void dbToFilesDumpWorks() { } ), new SimpleTest<>( - "rental table data (10K+ rows) is not empty", + "rental table data (10K+ rows) exists and is empty", (path) -> { - return ! Files.readAllLines(path.resolve(".dbgit/public/rental.csv")).isEmpty(); + return Files.readAllLines(path.resolve(".dbgit/public/rental.csv")).isEmpty(); } ) ); From 585bff9f8771ac00a59cd5e44cb7e44c6c158799 Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 4 Jun 2021 18:39:20 +0300 Subject: [PATCH 64/68] Fix SelfTest.java running "throwable must not be null" error. Now works as expected. --- .../java/ru/fusionsoft/dbgit/integration/SelfTest.java | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java b/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java index da85706..73eacc6 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/SelfTest.java @@ -67,11 +67,8 @@ public final void failsToFalseOnException() { new Patch() { @Override public void apply(Path root) throws Exception { - System.out.println("access " - + root.toString()); - throw new Error( - "dummy error" - ); + System.out.println("access " + root.toString()); + throw new RuntimeException("dummy error"); } } ), From 0775fc7b641564d501d4f69b34d623c248bc66d8 Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 4 Jun 2021 18:49:07 +0300 Subject: [PATCH 65/68] Add backups enabled DbGitIntegrationTestBasic#gitToDbRestoreWorks This scenario uses sequential restore and can cause some errors in backup adapters when running --- .../DbGitIntegrationTestBasic.java | 4 ++++ .../dbgit/CharsDbGitConfigBackupEnabled.java | 22 +++++++++++++++++++ .../dbgit/CharsDbGitConfigDefault.java | 22 +++++++++++++++++++ 3 files changed, 48 insertions(+) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbGitConfigBackupEnabled.java create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbGitConfigDefault.java diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java index 780b12d..ac1b293 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java @@ -19,6 +19,7 @@ import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemoteTestRepo; import ru.fusionsoft.dbgit.integration.primitives.chars.CommitsFromRepo; import ru.fusionsoft.dbgit.integration.primitives.chars.LinesOfUnsafeScalar; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit.CharsDbGitConfigBackupEnabled; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckout; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckoutHard; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitClonesRepo; @@ -252,12 +253,15 @@ public final void gitToDbRestoreWorks() throws Exception { new PathPatchDbGitCheckout(nameOfSourceBranch, "-b", "-nodb"), new PathPatchDbGitCheckout(commitNames.get(0), "-nodb", "-v"), new PathPatchDbGitLink(linkArgs), + new PathPatchCreatingFile(".dbgit/dbgitconfig", new CharsDbGitConfigBackupEnabled()), new PathPatchDbGitRestore("-r", "-v"), new PathPatchDbGitCheckoutHard(commitNames.get(1), "-nodb", "-v"), new PathPatchDbGitLink(linkArgs), + new PathPatchCreatingFile(".dbgit/dbgitconfig", new CharsDbGitConfigBackupEnabled()), new PathPatchDbGitRestore("-r", "-v"), new PathPatchDbGitCheckoutHard(commitNames.get(2), "-nodb", "-v"), new PathPatchDbGitLink(linkArgs), + new PathPatchCreatingFile(".dbgit/dbgitconfig", new CharsDbGitConfigBackupEnabled()), new PathPatchDbGitRestore("-r", "-v") ), new ProjectTestResourcesCleanDirectoryPath("04") diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbGitConfigBackupEnabled.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbGitConfigBackupEnabled.java new file mode 100644 index 0000000..c1f79ed --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbGitConfigBackupEnabled.java @@ -0,0 +1,22 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit; + +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public class CharsDbGitConfigBackupEnabled extends CharSequenceEnvelope { + public CharsDbGitConfigBackupEnabled() { + super(() -> { + return "[core]\n" + + "MAX_ROW_COUNT_FETCH = 10000\n" + + "LIMIT_FETCH = true\n" + + "LOG_ROTATE = 31\n" + + "LANG = ENG\n" + + "SCRIPT_ROTATE = 31\n" + + "TO_MAKE_BACKUP = true\n" + + "BACKUP_TO_SCHEME = true\n" + + "BACKUP_TABLEDATA = true\n" + + "PORTION_SIZE = 50000\n" + + "TRY_COUNT = 1000\n" + + "TRY_DELAY = 10\n"; + }); + } +} diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbGitConfigDefault.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbGitConfigDefault.java new file mode 100644 index 0000000..09e219e --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbGitConfigDefault.java @@ -0,0 +1,22 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit; + +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public class CharsDbGitConfigDefault extends CharSequenceEnvelope { + public CharsDbGitConfigDefault() { + super(()->{ + return "[core]\n" + + "MAX_ROW_COUNT_FETCH = 10000\n" + + "LIMIT_FETCH = true\n" + + "LOG_ROTATE = 31\n" + + "LANG = ENG\n" + + "SCRIPT_ROTATE = 31\n" + + "TO_MAKE_BACKUP = false\n" + + "BACKUP_TO_SCHEME = true\n" + + "BACKUP_TABLEDATA = true\n" + + "PORTION_SIZE = 50000\n" + + "TRY_COUNT = 1000\n" + + "TRY_DELAY = 10\n"; + }); + } +} From ce0026f929fefb032a67f85527e284fcafb40b8b Mon Sep 17 00:00:00 2001 From: rocket Date: Mon, 7 Jun 2021 20:25:33 +0300 Subject: [PATCH 66/68] Add template code for UDTs, Enums and Domains Meta/DB objects support DBEnum/DBUserDefinedType/DBDomain are instances of MetaSql, that's why no modification in Backup adapters needed --- .../fusionsoft/dbgit/adapters/DBAdapter.java | 3 ++ .../fusionsoft/dbgit/adapters/IDBAdapter.java | 11 ++++- .../dbgit/core/GitMetaDataManager.java | 8 +++- .../fusionsoft/dbgit/dbobjects/DBDomain.java | 13 ++++++ .../ru/fusionsoft/dbgit/dbobjects/DBEnum.java | 13 ++++++ .../dbgit/dbobjects/DBUserDefinedType.java | 13 ++++++ .../fusionsoft/dbgit/meta/DBGitMetaType.java | 33 ++++++++++++++- .../ru/fusionsoft/dbgit/meta/MetaDomain.java | 40 +++++++++++++++++++ .../ru/fusionsoft/dbgit/meta/MetaEnum.java | 32 +++++++++++++++ .../ru/fusionsoft/dbgit/meta/MetaUDT.java | 40 +++++++++++++++++++ .../dbgit/mssql/DBAdapterMssql.java | 33 +++++++++++++++ .../dbgit/mysql/DBAdapterMySql.java | 36 +++++++++++++++++ .../dbgit/oracle/DBAdapterOracle.java | 37 ++++++++++++++++- .../dbgit/postgres/DBAdapterPostgres.java | 33 +++++++++++++++ .../postgres/DBRestoreDomainPostgres.java | 17 ++++++++ .../dbgit/postgres/DBRestoreEnumPostgres.java | 17 ++++++++ .../dbgit/postgres/DBRestoreUDTPostgres.java | 17 ++++++++ .../FactoryDBAdapterRestorePostgres.java | 3 ++ 18 files changed, 394 insertions(+), 5 deletions(-) create mode 100644 src/main/java/ru/fusionsoft/dbgit/dbobjects/DBDomain.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/dbobjects/DBEnum.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/dbobjects/DBUserDefinedType.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/meta/MetaDomain.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/meta/MetaEnum.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/meta/MetaUDT.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreDomainPostgres.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreEnumPostgres.java create mode 100644 src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUDTPostgres.java diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index e128dee..b9dff97 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -169,6 +169,9 @@ private void printRestoreMessage(IMetaObject obj) { if(obj instanceof MetaView){ leafName = "restoreView"; } if(obj instanceof MetaTrigger){ leafName = "restoreTrigger"; } if(obj instanceof MetaSchema){ leafName = "restoreSchema"; } + if(obj instanceof MetaSchema){ leafName = "restoreUDT"; } + if(obj instanceof MetaEnum){ leafName = "restoreEnum"; } + if(obj instanceof MetaDomain){ leafName = "restoreDomain"; } if(obj instanceof MetaRole){ leafName = "restoreRole"; } if(obj instanceof MetaProcedure){ leafName = "restorePrc"; } if(obj instanceof MetaPackage){ leafName = "restorePkg"; } diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java index ecad994..0d366f6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/IDBAdapter.java @@ -7,6 +7,8 @@ import ru.fusionsoft.dbgit.core.ExceptionDBGit; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; +import ru.fusionsoft.dbgit.dbobjects.DBDomain; +import ru.fusionsoft.dbgit.dbobjects.DBEnum; import ru.fusionsoft.dbgit.dbobjects.DBFunction; import ru.fusionsoft.dbgit.dbobjects.DBIndex; import ru.fusionsoft.dbgit.dbobjects.DBPackage; @@ -21,6 +23,7 @@ import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; import ru.fusionsoft.dbgit.dbobjects.DBTrigger; import ru.fusionsoft.dbgit.dbobjects.DBUser; +import ru.fusionsoft.dbgit.dbobjects.DBUserDefinedType; import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMapMetaObject; @@ -143,7 +146,13 @@ public interface IDBAdapter { public Map getUsers(); public Map getRoles(); - + Map getUDTs(String schema); + Map getDomains(String schema); + Map getEnums(String schema); + DBUserDefinedType getUDT(String schema, String name); + DBDomain getDomain(String schema, String name); + DBEnum getEnum(String schema, String name); + public boolean userHasRightsToGetDdlOfOtherUsers(); public IFactoryDBBackupAdapter getBackupAdapterFactory(); diff --git a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java index a95d943..bf50d04 100644 --- a/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java +++ b/src/main/java/ru/fusionsoft/dbgit/core/GitMetaDataManager.java @@ -94,7 +94,7 @@ private void addToMapSqlObject( objs.put(obj); } - } + } public boolean loadFromDB(IMetaObject obj) throws ExceptionDBGit { try { @@ -241,6 +241,12 @@ public IMapMetaObject loadDBMetaData(boolean includeBackupSchemas) throws Except addToMapSqlObject(dbObjs, adapter.getProcedures(schema.getName()), DBGitMetaType.DbGitProcedure); if (!ignore.matchOne(schema.getName() + "/*." + DBGitMetaType.DbGitView.getValue())) addToMapSqlObject(dbObjs, adapter.getViews(schema.getName()), DBGitMetaType.DbGitView); + if (!ignore.matchOne(schema.getName() + "/*." + DBGitMetaType.DBGitEnum.getValue())) + addToMapSqlObject(dbObjs, adapter.getEnums(schema.getName()), DBGitMetaType.DBGitEnum); + if (!ignore.matchOne(schema.getName() + "/*." + DBGitMetaType.DBGitUserDefinedType.getValue())) + addToMapSqlObject(dbObjs, adapter.getUDTs(schema.getName()), DBGitMetaType.DBGitUserDefinedType); + if (!ignore.matchOne(schema.getName() + "/*." + DBGitMetaType.DBGitDomain.getValue())) + addToMapSqlObject(dbObjs, adapter.getDomains(schema.getName()), DBGitMetaType.DBGitDomain); } //data tables diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBDomain.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBDomain.java new file mode 100644 index 0000000..92c437d --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBDomain.java @@ -0,0 +1,13 @@ +package ru.fusionsoft.dbgit.dbobjects; + +import java.util.Set; +import ru.fusionsoft.dbgit.utils.StringProperties; + +public class DBDomain extends DBSQLObject { + public DBDomain() { + } + + public DBDomain(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBEnum.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBEnum.java new file mode 100644 index 0000000..dae9f76 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBEnum.java @@ -0,0 +1,13 @@ +package ru.fusionsoft.dbgit.dbobjects; + +import java.util.Set; +import ru.fusionsoft.dbgit.utils.StringProperties; + +public class DBEnum extends DBSQLObject { + public DBEnum() { + } + + public DBEnum(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBUserDefinedType.java b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBUserDefinedType.java new file mode 100644 index 0000000..cf064a9 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/dbobjects/DBUserDefinedType.java @@ -0,0 +1,13 @@ +package ru.fusionsoft.dbgit.dbobjects; + +import java.util.Set; +import ru.fusionsoft.dbgit.utils.StringProperties; + +public class DBUserDefinedType extends DBSQLObject { + public DBUserDefinedType() { + } + + public DBUserDefinedType(String name, StringProperties options, String schema, String owner, Set dependencies, String sql) { + super(name, options, schema, owner, dependencies, sql); + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/DBGitMetaType.java b/src/main/java/ru/fusionsoft/dbgit/meta/DBGitMetaType.java index 73b678c..3f48dc7 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/DBGitMetaType.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/DBGitMetaType.java @@ -46,6 +46,36 @@ public Integer getPriority() { } }, + DBGitUserDefinedType("udt"){ + public Class getMetaClass() { + return MetaUDT.class; + } + + public Integer getPriority() { + return 11; + } + }, + + DBGitEnum("enum"){ + public Class getMetaClass() { + return MetaUDT.class; + } + + public Integer getPriority() { + return 12; + } + }, + + DBGitDomain("domain"){ + public Class getMetaClass() { + return MetaUDT.class; + } + + public Integer getPriority() { + return 13; + } + }, + DBGitSequence("seq"){ public Class getMetaClass() { return MetaSequence.class; @@ -134,8 +164,7 @@ public Class getMetaClass() { public Integer getPriority() { return 210; } - } - ; + }; private static Map listAllTypes; static { diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaDomain.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaDomain.java new file mode 100644 index 0000000..a7aa969 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaDomain.java @@ -0,0 +1,40 @@ +package ru.fusionsoft.dbgit.meta; + +import ru.fusionsoft.dbgit.adapters.AdapterFactory; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.dbobjects.DBDomain; +import ru.fusionsoft.dbgit.dbobjects.DBSQLObject; + +public class MetaDomain extends MetaSql { + public MetaDomain() { + } + + public MetaDomain(DBSQLObject sqlObject) throws ExceptionDBGit { + super(sqlObject); + } + + /** + * @return Type meta object + */ + @Override + public final IDBGitMetaType getType() { + return DBGitMetaType.DBGitDomain; + } + + /** + * load current object from DB + */ + @Override + public final boolean loadFromDB() throws ExceptionDBGit { + final IDBAdapter adapter = AdapterFactory.createAdapter(); + final NameMeta nm = MetaObjectFactory.parseMetaName(name); + final DBDomain dbObject = adapter.getDomain(nm.getSchema(), nm.getName()); + + if (dbObject != null) { + setSqlObject(dbObject); + return true; + } else + return false; + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaEnum.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaEnum.java new file mode 100644 index 0000000..fd41f51 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaEnum.java @@ -0,0 +1,32 @@ +package ru.fusionsoft.dbgit.meta; + +import ru.fusionsoft.dbgit.adapters.AdapterFactory; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.dbobjects.DBEnum; + +public class MetaEnum extends MetaSql { + /** + * @return Type meta object + */ + @Override + public IDBGitMetaType getType() { + return DBGitMetaType.DBGitEnum; + } + + /** + * load current object from DB + */ + @Override + public boolean loadFromDB() throws ExceptionDBGit { + final IDBAdapter adapter = AdapterFactory.createAdapter(); + final NameMeta nm = MetaObjectFactory.parseMetaName(name); + final DBEnum dbObject = adapter.getEnum(nm.getSchema(), nm.getName()); + + if (dbObject != null) { + setSqlObject(dbObject); + return true; + } else + return false; + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/MetaUDT.java b/src/main/java/ru/fusionsoft/dbgit/meta/MetaUDT.java new file mode 100644 index 0000000..014fd0d --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/meta/MetaUDT.java @@ -0,0 +1,40 @@ +package ru.fusionsoft.dbgit.meta; + +import ru.fusionsoft.dbgit.adapters.AdapterFactory; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.dbobjects.DBSQLObject; +import ru.fusionsoft.dbgit.dbobjects.DBUserDefinedType; + +public class MetaUDT extends MetaSql { + public MetaUDT() { + } + + public MetaUDT(DBSQLObject sqlObject) throws ExceptionDBGit { + super(sqlObject); + } + + /** + * @return Type meta object + */ + @Override + public final IDBGitMetaType getType() { + return DBGitMetaType.DBGitUserDefinedType; + } + + /** + * load current object from DB + */ + @Override + public final boolean loadFromDB() throws ExceptionDBGit { + final IDBAdapter adapter = AdapterFactory.createAdapter(); + final NameMeta nm = MetaObjectFactory.parseMetaName(name); + final DBUserDefinedType dbObject = adapter.getUDT(nm.getSchema(), nm.getName()); + + if (dbObject != null) { + setSqlObject(dbObject); + return true; + } else + return false; + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java index 5a32860..f33d99d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mssql/DBAdapterMssql.java @@ -1163,6 +1163,39 @@ public Map getRoles() { return listRole; } + @Override + public Map getUDTs(String schema) { + return Collections.emptyMap(); + } + + @Override + public Map getDomains(String schema) { + return Collections.emptyMap(); + } + + @Override + public Map getEnums(String schema) { + return Collections.emptyMap(); + } + + @Override + public DBUserDefinedType getUDT(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + + @Override + public DBDomain getDomain(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + + @Override + public DBEnum getEnum(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + @Override public boolean userHasRightsToGetDdlOfOtherUsers() { try{ diff --git a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java index 774fe87..563da91 100644 --- a/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java +++ b/src/main/java/ru/fusionsoft/dbgit/mysql/DBAdapterMySql.java @@ -24,6 +24,8 @@ import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.core.db.FieldType; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; +import ru.fusionsoft.dbgit.dbobjects.DBDomain; +import ru.fusionsoft.dbgit.dbobjects.DBEnum; import ru.fusionsoft.dbgit.dbobjects.DBFunction; import ru.fusionsoft.dbgit.dbobjects.DBIndex; import ru.fusionsoft.dbgit.dbobjects.DBPackage; @@ -37,6 +39,7 @@ import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; import ru.fusionsoft.dbgit.dbobjects.DBTrigger; import ru.fusionsoft.dbgit.dbobjects.DBUser; +import ru.fusionsoft.dbgit.dbobjects.DBUserDefinedType; import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMapMetaObject; import ru.fusionsoft.dbgit.meta.TreeMapMetaObject; @@ -821,6 +824,39 @@ public Map getUsers() { @Override public Map getRoles() { return Collections.emptyMap(); } + @Override + public Map getUDTs(String schema) { + return Collections.emptyMap(); + } + + @Override + public Map getDomains(String schema) { + return Collections.emptyMap(); + } + + @Override + public Map getEnums(String schema) { + return Collections.emptyMap(); + } + + @Override + public DBUserDefinedType getUDT(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + + @Override + public DBDomain getDomain(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + + @Override + public DBEnum getEnum(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + protected String getFieldType(ResultSet rs) { try { final StringBuilder type = new StringBuilder(); diff --git a/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java b/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java index c813cf5..032af9a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java +++ b/src/main/java/ru/fusionsoft/dbgit/oracle/DBAdapterOracle.java @@ -27,6 +27,8 @@ import ru.fusionsoft.dbgit.data_table.StringData; import ru.fusionsoft.dbgit.data_table.TextFileData; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; +import ru.fusionsoft.dbgit.dbobjects.DBDomain; +import ru.fusionsoft.dbgit.dbobjects.DBEnum; import ru.fusionsoft.dbgit.dbobjects.DBFunction; import ru.fusionsoft.dbgit.dbobjects.DBIndex; import ru.fusionsoft.dbgit.dbobjects.DBPackage; @@ -41,6 +43,7 @@ import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; import ru.fusionsoft.dbgit.dbobjects.DBTrigger; import ru.fusionsoft.dbgit.dbobjects.DBUser; +import ru.fusionsoft.dbgit.dbobjects.DBUserDefinedType; import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMapMetaObject; import ru.fusionsoft.dbgit.meta.IMetaObject; @@ -958,7 +961,39 @@ public Map getRoles() { return listRole; } - + @Override + public Map getUDTs(String schema) { + return Collections.emptyMap(); + } + + @Override + public Map getDomains(String schema) { + return Collections.emptyMap(); + } + + @Override + public Map getEnums(String schema) { + return Collections.emptyMap(); + } + + @Override + public DBUserDefinedType getUDT(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + + @Override + public DBDomain getDomain(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + + @Override + public DBEnum getEnum(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + static { reservedWords.add("ACCESS"); reservedWords.add("ADD"); diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index 21d5e12..79acb45 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -1010,6 +1010,39 @@ public Map getRoles() { return listRole; } + @Override + public Map getUDTs(String schema) { + return Collections.emptyMap(); + } + + @Override + public Map getDomains(String schema) { + return Collections.emptyMap(); + } + + @Override + public Map getEnums(String schema) { + return Collections.emptyMap(); + } + + @Override + public DBUserDefinedType getUDT(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + + @Override + public DBDomain getDomain(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + + @Override + public DBEnum getEnum(String schema, String name) { + final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); + throw new ExceptionDBGitObjectNotFound(msg); + } + @Override public boolean userHasRightsToGetDdlOfOtherUsers() { return true; } @Override diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreDomainPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreDomainPostgres.java new file mode 100644 index 0000000..dc9e529 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreDomainPostgres.java @@ -0,0 +1,17 @@ +package ru.fusionsoft.dbgit.postgres; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.core.NotImplementedExceptionDBGitRuntime; +import ru.fusionsoft.dbgit.meta.IMetaObject; + +public class DBRestoreDomainPostgres extends DBRestoreAdapter { + @Override + public final boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public final void removeMetaObject(IMetaObject obj) throws Exception { + throw new NotImplementedExceptionDBGitRuntime(); + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreEnumPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreEnumPostgres.java new file mode 100644 index 0000000..cccbd38 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreEnumPostgres.java @@ -0,0 +1,17 @@ +package ru.fusionsoft.dbgit.postgres; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.core.NotImplementedExceptionDBGitRuntime; +import ru.fusionsoft.dbgit.meta.IMetaObject; + +public class DBRestoreEnumPostgres extends DBRestoreAdapter { + @Override + public final boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public final void removeMetaObject(IMetaObject obj) throws Exception { + throw new NotImplementedExceptionDBGitRuntime(); + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUDTPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUDTPostgres.java new file mode 100644 index 0000000..9190a16 --- /dev/null +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUDTPostgres.java @@ -0,0 +1,17 @@ +package ru.fusionsoft.dbgit.postgres; + +import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; +import ru.fusionsoft.dbgit.core.NotImplementedExceptionDBGitRuntime; +import ru.fusionsoft.dbgit.meta.IMetaObject; + +public class DBRestoreUDTPostgres extends DBRestoreAdapter { + @Override + public final boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { + throw new NotImplementedExceptionDBGitRuntime(); + } + + @Override + public final void removeMetaObject(IMetaObject obj) throws Exception { + throw new NotImplementedExceptionDBGitRuntime(); + } +} diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDBAdapterRestorePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDBAdapterRestorePostgres.java index a9e8f3f..c7c7e1a 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDBAdapterRestorePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/FactoryDBAdapterRestorePostgres.java @@ -22,6 +22,9 @@ public class FactoryDBAdapterRestorePostgres implements IFactoryDBAdapterRestote static { Map aMap = new HashMap(); aMap.put(DBGitMetaType.DBGitSchema.getValue(), new DBRestoreSchemaPostgres()); + aMap.put(DBGitMetaType.DBGitUserDefinedType.getValue(), new DBRestoreUDTPostgres()); + aMap.put(DBGitMetaType.DBGitDomain.getValue(), new DBRestoreDomainPostgres()); + aMap.put(DBGitMetaType.DBGitEnum.getValue(), new DBRestoreEnumPostgres()); aMap.put(DBGitMetaType.DBGitTableSpace.getValue(), new DBRestoreTableSpacePostgres()); aMap.put(DBGitMetaType.DBGitRole.getValue(), new DBRestoreRolePostgres()); aMap.put(DBGitMetaType.DBGitSequence.getValue(), new DBRestoreSequencePostgres()); From 730ded92be5a4b86606e7ea252f4b6ef9f19f4d1 Mon Sep 17 00:00:00 2001 From: rocket Date: Tue, 8 Jun 2021 22:04:41 +0300 Subject: [PATCH 67/68] Add implementation of DBAdapterPostgres.getEnums, DBAdapterPostgres.getDomains Add IT case just testing fetch and existence of such objects Disabled DbGitIntegrationTestNotebook for automatic test execution not to accidentally burn test repos --- .../dbgit/adapters/DBAdapterProxy.java | 35 +++++- .../fusionsoft/dbgit/meta/DBGitMetaType.java | 4 +- .../dbgit/postgres/DBAdapterPostgres.java | 118 +++++++++++++++++- .../DbGitIntegrationTestBasic.java | 17 ++- .../DbGitIntegrationTestNotebook.java | 2 + .../dbgit/CharsDbIgnoreWithDataAndTypes.java | 25 ++++ 6 files changed, 194 insertions(+), 7 deletions(-) create mode 100644 src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreWithDataAndTypes.java diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java index 6e0ecc6..8f7797d 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapterProxy.java @@ -8,6 +8,8 @@ import ru.fusionsoft.dbgit.core.SchemaSynonym; import ru.fusionsoft.dbgit.core.db.DbType; import ru.fusionsoft.dbgit.dbobjects.DBConstraint; +import ru.fusionsoft.dbgit.dbobjects.DBDomain; +import ru.fusionsoft.dbgit.dbobjects.DBEnum; import ru.fusionsoft.dbgit.dbobjects.DBFunction; import ru.fusionsoft.dbgit.dbobjects.DBIndex; import ru.fusionsoft.dbgit.dbobjects.DBPackage; @@ -22,6 +24,7 @@ import ru.fusionsoft.dbgit.dbobjects.DBTableSpace; import ru.fusionsoft.dbgit.dbobjects.DBTrigger; import ru.fusionsoft.dbgit.dbobjects.DBUser; +import ru.fusionsoft.dbgit.dbobjects.DBUserDefinedType; import ru.fusionsoft.dbgit.dbobjects.DBView; import ru.fusionsoft.dbgit.meta.IMapMetaObject; @@ -186,7 +189,37 @@ public Map getUsers() { public Map getRoles() { return adapter.getRoles(); } - + + @Override + public Map getUDTs(String schema) { + return adapter.getUDTs(schema); + } + + @Override + public Map getDomains(String schema) { + return adapter.getDomains(schema); + } + + @Override + public Map getEnums(String schema) { + return adapter.getEnums(schema); + } + + @Override + public DBUserDefinedType getUDT(String schema, String name) { + return adapter.getUDT(schema, name); + } + + @Override + public DBDomain getDomain(String schema, String name) { + return adapter.getDomain(schema, name); + } + + @Override + public DBEnum getEnum(String schema, String name) { + return adapter.getEnum(schema, name); + } + public T schemaSynonymMap(T object) { if (object == null) return null; diff --git a/src/main/java/ru/fusionsoft/dbgit/meta/DBGitMetaType.java b/src/main/java/ru/fusionsoft/dbgit/meta/DBGitMetaType.java index 3f48dc7..78452b6 100644 --- a/src/main/java/ru/fusionsoft/dbgit/meta/DBGitMetaType.java +++ b/src/main/java/ru/fusionsoft/dbgit/meta/DBGitMetaType.java @@ -58,7 +58,7 @@ public Integer getPriority() { DBGitEnum("enum"){ public Class getMetaClass() { - return MetaUDT.class; + return MetaEnum.class; } public Integer getPriority() { @@ -68,7 +68,7 @@ public Integer getPriority() { DBGitDomain("domain"){ public Class getMetaClass() { - return MetaUDT.class; + return MetaDomain.class; } public Integer getPriority() { diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index 79acb45..0f9fc6f 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -9,6 +9,7 @@ import com.diogonunes.jcdp.color.api.Ansi; import com.google.common.collect.ImmutableMap; +import java.util.stream.Collectors; import org.apache.commons.lang3.exception.ExceptionUtils; import ru.fusionsoft.dbgit.adapters.*; import ru.fusionsoft.dbgit.core.*; @@ -1012,17 +1013,130 @@ public Map getRoles() { @Override public Map getUDTs(String schema) { + System.out.println("getting UDT's"); return Collections.emptyMap(); } @Override public Map getDomains(String schema) { - return Collections.emptyMap(); + System.out.println("getting domains"); + final Map objects = new HashMap<>(); + final String query = + "SELECT \n" + + " n.nspname,\n" + + " t.typname, \n" + + " dom.data_type, \n" + + " dom.domain_default,\n" + + " r.rolname,\n" + + " pg_catalog.obj_description ( t.oid, 'pg_type' ) AS description\n" + + "FROM pg_type t \n" + + "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace \n" + + "RIGHT JOIN information_schema.domains dom ON dom.domain_name = t.typname AND dom.domain_schema = n.nspname\n" + + "LEFT JOIN pg_roles r ON r.oid = t.typowner\n" + + "WHERE (t.typrelid = 0 OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)) \n" + + "AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)\n" + + "AND n.nspname NOT IN ('pg_catalog', 'information_schema')\n" + + "AND dom.domain_schema = '"+schema+"'"; + + System.out.println("query = " + query); + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + + while (rs.next()) { + final String name = rs.getString("typname"); + final String owner = rs.getString("rolname"); + final String type = rs.getString("data_type"); + final String defaultValue = rs.getString("domain_default"); + + final List constraintSqls = new ArrayList<>(); + final String constraintsQuery = + "SELECT con.conname, con.convalidated, con.consrc\n" + + "FROM information_schema.domains dom\n" + + "INNER JOIN information_schema.domain_constraints dcon ON dcon.domain_schema = dom.domain_schema AND dcon.domain_name = dom.domain_name\n" + + "INNER JOIN pg_catalog.pg_constraint con ON dcon.constraint_name = con.conname\n" + + "WHERE dom.domain_schema = '"+schema+"' AND dom.domain_name = '"+name+"'"; + try (Statement stmt2 = getConnection().createStatement(); ResultSet conRs = stmt2.executeQuery(constraintsQuery)) { + while (conRs.next()) { + final String conName = conRs.getString("conname"); + final String conSrc = conRs.getString("consrc"); + final Boolean conIsValidated = conRs.getBoolean("convalidated"); + final String conSql = MessageFormat.format( + "ALTER DOMAIN {0}.{1} ADD CONSTRAINT {2} CHECK {3} {4};", + escapeNameIfNeeded(schema), + escapeNameIfNeeded(name), + escapeNameIfNeeded(conName), + conSrc, + conIsValidated ? "" : "NOT VALID" + ); + constraintSqls.add(conSql); + System.out.println("conSql = " + conSql); + } + } + + final StringProperties options = new StringProperties(rs); + final String sql = MessageFormat.format( + "CREATE DOMAIN {0}.{1} AS {2} {3}; ALTER DOMAIN {0}.{1} OWNER TO {4};\n{5}", + escapeNameIfNeeded(schema), escapeNameIfNeeded(name), type, defaultValue != null ? "DEFAULT " + defaultValue : "", owner, + String.join("\n", constraintSqls) + ); + System.out.println("sql = " + sql); + + DBDomain object = new DBDomain(name, options, schema, owner, Collections.emptySet(), sql); + objects.put(name, object); + } + + } catch (Exception e) { + throw new ExceptionDBGitRunTime(e); + } + + return objects; } @Override public Map getEnums(String schema) { - return Collections.emptyMap(); + System.out.println("getting enums"); + final Map objects = new HashMap<>(); + final String query = + "SELECT t.typname, r.rolname, pg_catalog.obj_description ( t.oid, 'pg_type' ) AS description," + + "ARRAY( \n" + + " SELECT e.enumlabel\n" + + " FROM pg_catalog.pg_enum e\n" + + " WHERE e.enumtypid = t.oid\n" + + " ORDER BY e.oid \n" + + ") AS elements\n" + + "FROM pg_type t \n" + + "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace \n" + + "LEFT JOIN pg_roles r ON r.oid = t.typowner\n" + + "WHERE (t.typrelid = 0 OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)) \n" + + "AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)\n" + + "AND n.nspname NOT IN ('pg_catalog', 'information_schema')\n" + + "AND n.nspname = '"+schema+"'" + + "AND t.typtype = 'e'"; + + System.out.println("query = " + query); + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + + while (rs.next()) { + final String name = rs.getString("typname"); + final String owner = rs.getString("rolname"); + final StringProperties options = new StringProperties(rs); + final List elements = Arrays.stream((String[]) rs.getArray("elements").getArray()) + .map( x->"'"+x+"'") + .collect(Collectors.toList()); + final String sql = MessageFormat.format( + "CREATE TYPE {0}.{1} AS ENUM ({2});\nALTER TYPE {0}.{1} ONWER TO {3}", + schema, name, String.join(",", elements), owner + ); + System.out.println("sql = " + sql); + + DBEnum object = new DBEnum(name, options, schema, owner, Collections.emptySet(), sql); + objects.put(name, object); + } + + } catch (Exception e) { + throw new ExceptionDBGitRunTime(e); + } + + return objects; } @Override diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java index 780b12d..680c5c7 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java @@ -19,6 +19,7 @@ import ru.fusionsoft.dbgit.integration.primitives.args.specific.ArgsDbGitAddRemoteTestRepo; import ru.fusionsoft.dbgit.integration.primitives.chars.CommitsFromRepo; import ru.fusionsoft.dbgit.integration.primitives.chars.LinesOfUnsafeScalar; +import ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit.CharsDbIgnoreWithDataAndTypes; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckout; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitCheckoutHard; import ru.fusionsoft.dbgit.integration.primitives.patch.specific.PathPatchDbGitClonesRepo; @@ -154,10 +155,10 @@ public final void dbToFilesDumpWorks() { new ArgsExplicit("add", "\"*\""), new PathWithFiles( - new PathPatchCreatingFile(".dbgit/.dbignore", new CharsDbIgnoreWithTableData()), + new PathPatchCreatingFile(".dbgit/.dbignore", new CharsDbIgnoreWithDataAndTypes()), new PathAfterDbGitRun( - new ArgsDbGitLinkPgAuto("pagilla"), + new ArgsDbGitLinkPgAuto("dvdrental"), new PathAfterDbGitRun( new ArgsExplicit("init"), @@ -191,6 +192,18 @@ public final void dbToFilesDumpWorks() { (path) -> { return Files.readAllLines(path.resolve(".dbgit/public/rental.csv")).isEmpty(); } + ), + new SimpleTest<>( + "mpaa_rating.enum exists", + (path) -> { + return path.resolve(".dbgit/public/mpaa_rating.enum").toFile().exists(); + } + ), + new SimpleTest<>( + "year.domain exists", + (path) -> { + return path.resolve(".dbgit/public/year.domain").toFile().exists(); + } ) ); diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestNotebook.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestNotebook.java index b60b53c..218bebc 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestNotebook.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestNotebook.java @@ -3,6 +3,7 @@ import java.nio.file.Path; import java.text.MessageFormat; import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import ru.fusionsoft.dbgit.integration.primitives.PatchSequential; @@ -29,6 +30,7 @@ import ru.fusionsoft.dbgit.integration.primitives.path.specific.dbgit.scenarios.PathAfterDbGitDumpsDbSchemaToGit; @Tag("notebook") +@Disabled public class DbGitIntegrationTestNotebook { @Test public final void appendsDbSchemaToBranchOfTestRepo() { diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreWithDataAndTypes.java b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreWithDataAndTypes.java new file mode 100644 index 0000000..c3725d4 --- /dev/null +++ b/src/test/java/ru/fusionsoft/dbgit/integration/primitives/chars/specific/dbgit/CharsDbIgnoreWithDataAndTypes.java @@ -0,0 +1,25 @@ +package ru.fusionsoft.dbgit.integration.primitives.chars.specific.dbgit; + +import ru.fusionsoft.dbgit.integration.primitives.chars.CharSequenceEnvelope; + +public class CharsDbIgnoreWithDataAndTypes extends CharSequenceEnvelope { + public CharsDbIgnoreWithDataAndTypes() { + super(()->{ + return "*\n" + + "!public/*.ts\n" + + "!public/*.sch\n" + + "!public/*.seq\n" + + "!public/*.tbl\n" + + "!public/*.pkg\n" + + "!public/*.trg\n" + + "!public/*.prc\n" + + "!public/*.fnc\n" + + "!public/*.vw\n" + + "!public/*.blob\n" + + "!public/*.udt\n" + + "!public/*.enum\n" + + "!public/*.domain\n" + + "!public/*.csv\n"; + }); + } +} From ddf015c8da0e1eaf8d3dffcc5e5851ce4983d6e4 Mon Sep 17 00:00:00 2001 From: rocket Date: Fri, 11 Jun 2021 03:38:44 +0300 Subject: [PATCH 68/68] Impl. of DBRestore(Domain|Enum|UDT)Postgres Fix of some new implementations errors Improve test case with custom types --- .../fusionsoft/dbgit/adapters/DBAdapter.java | 2 +- .../dbgit/postgres/DBAdapterPostgres.java | 122 ++++++++++++++---- .../postgres/DBRestoreDomainPostgres.java | 113 +++++++++++++++- .../dbgit/postgres/DBRestoreEnumPostgres.java | 103 ++++++++++++++- .../postgres/DBRestoreTablePostgres.java | 2 + .../dbgit/postgres/DBRestoreUDTPostgres.java | 108 +++++++++++++++- src/main/resources/lang/eng.yaml | 3 + .../DbGitIntegrationTestBasic.java | 10 +- 8 files changed, 421 insertions(+), 42 deletions(-) diff --git a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java index b9dff97..ff75722 100644 --- a/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java +++ b/src/main/java/ru/fusionsoft/dbgit/adapters/DBAdapter.java @@ -169,7 +169,7 @@ private void printRestoreMessage(IMetaObject obj) { if(obj instanceof MetaView){ leafName = "restoreView"; } if(obj instanceof MetaTrigger){ leafName = "restoreTrigger"; } if(obj instanceof MetaSchema){ leafName = "restoreSchema"; } - if(obj instanceof MetaSchema){ leafName = "restoreUDT"; } + if(obj instanceof MetaUDT){ leafName = "restoreUDT"; } if(obj instanceof MetaEnum){ leafName = "restoreEnum"; } if(obj instanceof MetaDomain){ leafName = "restoreDomain"; } if(obj instanceof MetaRole){ leafName = "restoreRole"; } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java index 0f9fc6f..14b7f95 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBAdapterPostgres.java @@ -1013,8 +1013,68 @@ public Map getRoles() { @Override public Map getUDTs(String schema) { - System.out.println("getting UDT's"); - return Collections.emptyMap(); + final Map objects = new HashMap<>(); + final String query = + "SELECT \n" + + " n.nspname AS schema,\n" + + " t.typname AS name, \n" + + " r.rolname AS owner,\n" + + " pg_catalog.obj_description ( t.oid, 'pg_type' ) AS description\n" + + "FROM pg_type t \n" + + "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace \n" + + "LEFT JOIN pg_roles r ON r.oid = t.typowner\n" + + "WHERE (t.typrelid = 0 OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)) \n" + + "AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)\n" + + "AND t.typtype = 'c'\n" + + "AND n.nspname = '"+schema+"'"; + + try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { + while (rs.next()) { + final String name = rs.getString("name"); + final String owner = rs.getString("owner"); + final List attributesSqls = new ArrayList<>(); + final String attributesQuery = + "SELECT \n" + + " attribute_name AS \"name\", \n" + + " data_type AS \"type\", \n" + + " ordinal_position AS \"order\"\n" + + "FROM information_schema.attributes a\n" + + "WHERE udt_schema = '"+schema+"' AND udt_name = '"+name+"'\n" + + "ORDER BY ordinal_position"; + try (Statement stmt2 = getConnection().createStatement(); ResultSet attributeRs = stmt2.executeQuery( + attributesQuery)) { + while (attributeRs.next()) { + final String attrName = attributeRs.getString("name"); + final String attrType = attributeRs.getString("type"); + final String udtAttrDefinition = MessageFormat.format( + "{0} {1}", + escapeNameIfNeeded(attrName), + attrType + ); + attributesSqls.add(udtAttrDefinition); + } + } + final StringProperties options = new StringProperties(); + final String sql = MessageFormat.format( + "CREATE TYPE {0}.{1} AS (\n{2}\n);\n" + + "ALTER TYPE {0}.{1} OWNER TO {3};", + escapeNameIfNeeded(schema), + escapeNameIfNeeded(name), + String.join(",\n ", attributesSqls), + owner + ); + + DBUserDefinedType object = new DBUserDefinedType(name, options, schema, owner, Collections.emptySet(), sql); + options.addChild("attributes", String.join(",", attributesSqls)); + options.addChild("description", rs.getString("description")); + objects.put(name, object); + } + + } catch (Exception e) { + throw new ExceptionDBGitRunTime(e); + } + + return objects; } @Override @@ -1024,7 +1084,7 @@ public Map getDomains(String schema) { final String query = "SELECT \n" + " n.nspname,\n" - + " t.typname, \n" + + " t.typname, \n" + " dom.data_type, \n" + " dom.domain_default,\n" + " r.rolname,\n" @@ -1038,7 +1098,6 @@ public Map getDomains(String schema) { + "AND n.nspname NOT IN ('pg_catalog', 'information_schema')\n" + "AND dom.domain_schema = '"+schema+"'"; - System.out.println("query = " + query); try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while (rs.next()) { @@ -1059,16 +1118,14 @@ public Map getDomains(String schema) { final String conName = conRs.getString("conname"); final String conSrc = conRs.getString("consrc"); final Boolean conIsValidated = conRs.getBoolean("convalidated"); - final String conSql = MessageFormat.format( + constraintSqls.add(MessageFormat.format( "ALTER DOMAIN {0}.{1} ADD CONSTRAINT {2} CHECK {3} {4};", - escapeNameIfNeeded(schema), - escapeNameIfNeeded(name), - escapeNameIfNeeded(conName), - conSrc, + escapeNameIfNeeded(schema), + escapeNameIfNeeded(name), + escapeNameIfNeeded(conName), + conSrc, conIsValidated ? "" : "NOT VALID" - ); - constraintSqls.add(conSql); - System.out.println("conSql = " + conSql); + )); } } @@ -1078,7 +1135,6 @@ public Map getDomains(String schema) { escapeNameIfNeeded(schema), escapeNameIfNeeded(name), type, defaultValue != null ? "DEFAULT " + defaultValue : "", owner, String.join("\n", constraintSqls) ); - System.out.println("sql = " + sql); DBDomain object = new DBDomain(name, options, schema, owner, Collections.emptySet(), sql); objects.put(name, object); @@ -1112,23 +1168,23 @@ public Map getEnums(String schema) { + "AND n.nspname = '"+schema+"'" + "AND t.typtype = 'e'"; - System.out.println("query = " + query); try (Statement stmt = getConnection().createStatement(); ResultSet rs = stmt.executeQuery(query);) { while (rs.next()) { final String name = rs.getString("typname"); final String owner = rs.getString("rolname"); - final StringProperties options = new StringProperties(rs); - final List elements = Arrays.stream((String[]) rs.getArray("elements").getArray()) - .map( x->"'"+x+"'") - .collect(Collectors.toList()); + final String elements = String.join( + ",", + Arrays.stream((String[]) rs.getArray("elements").getArray()).map( x->"'"+x+"'").collect(Collectors.toList()) + ); + final StringProperties options = new StringProperties(); final String sql = MessageFormat.format( - "CREATE TYPE {0}.{1} AS ENUM ({2});\nALTER TYPE {0}.{1} ONWER TO {3}", - schema, name, String.join(",", elements), owner + "CREATE TYPE {0}.{1} AS ENUM ({2});\nALTER TYPE {0}.{1} OWNER TO {3}", + schema, name, elements, owner ); - System.out.println("sql = " + sql); DBEnum object = new DBEnum(name, options, schema, owner, Collections.emptySet(), sql); + options.addChild("elements", elements); objects.put(name, object); } @@ -1141,20 +1197,32 @@ public Map getEnums(String schema) { @Override public DBUserDefinedType getUDT(String schema, String name) { - final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); - throw new ExceptionDBGitObjectNotFound(msg); + final Map udTs = getUDTs(schema); + if (udTs.containsKey(name)) { + return udTs.get(name); + } else { + throw new ExceptionDBGitObjectNotFound(lang.getValue("errors", "adapter", "objectNotFoundInDb").toString()); + } } @Override public DBDomain getDomain(String schema, String name) { - final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); - throw new ExceptionDBGitObjectNotFound(msg); + final Map domains = getDomains(schema); + if (domains.containsKey(name)) { + return domains.get(name); + } else { + throw new ExceptionDBGitObjectNotFound(lang.getValue("errors", "adapter", "objectNotFoundInDb").toString()); + } } @Override public DBEnum getEnum(String schema, String name) { - final String msg = lang.getValue("errors", "adapter", "objectNotFoundInDb").toString(); - throw new ExceptionDBGitObjectNotFound(msg); + final Map enums = getEnums(schema); + if (enums.containsKey(name)) { + return enums.get(name); + } else { + throw new ExceptionDBGitObjectNotFound(lang.getValue("errors", "adapter", "objectNotFoundInDb").toString()); + } } @Override diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreDomainPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreDomainPostgres.java index dc9e529..56039a1 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreDomainPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreDomainPostgres.java @@ -1,17 +1,122 @@ package ru.fusionsoft.dbgit.postgres; +import java.sql.Connection; +import java.text.MessageFormat; +import java.util.Map; import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.core.NotImplementedExceptionDBGitRuntime; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBDomain; +import ru.fusionsoft.dbgit.dbobjects.DBSQLObject; import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaDomain; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; public class DBRestoreDomainPostgres extends DBRestoreAdapter { @Override public final boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - throw new NotImplementedExceptionDBGitRuntime(); + final IDBAdapter adapter = getAdapter(); + final Connection connect = adapter.getConnection(); + try (final StatementLogging st = new StatementLogging( + connect, + adapter.getStreamOutputSqlCommand(), + adapter.isExecSql() + )) { + if (! ( obj instanceof MetaDomain )) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "metaTypeError").withParams( + obj.getName(), + "domain", + obj.getType().getValue() + ) + ); + } + final DBSQLObject restoreDomain = (DBSQLObject) obj.getUnderlyingDbObject(); + final Map domains = adapter.getDomains(restoreDomain.getSchema()); + + if (domains.containsKey(restoreDomain.getName())) { + final DBDomain currentDomain = domains.get(restoreDomain.getName()); + if ( + ! restoreDomain.getOptions().get("attributes").equals( + currentDomain.getOptions().get("attributes") + ) + ) { + st.execute(MessageFormat.format( + "DROP DOMAIN IF EXISTS {0}._deprecated_{1} RESTRICT;\n" + + "ALTER DOMAIN {0}.{1} RENAME TO _deprecated_{1};\n" + + "{2}", + currentDomain.getSchema(), currentDomain.getName(), getDdlEscaped(restoreDomain) + )); + } else { + if (! DBGitConfig.getInstance().getToIgnoreOnwer(false)) { + st.execute(getChangeOwnerDdl(currentDomain, restoreDomain.getOwner())); + } + } + } else { + st.execute(getDdlEscaped(restoreDomain)); + } + + } catch (Exception e) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), + e + ); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + return true; } @Override - public final void removeMetaObject(IMetaObject obj) throws Exception { - throw new NotImplementedExceptionDBGitRuntime(); + public void removeMetaObject(IMetaObject obj) throws Exception { + final IDBAdapter adapter = getAdapter(); + final Connection connect = adapter.getConnection(); + + try (StatementLogging st = new StatementLogging( + connect, + adapter.getStreamOutputSqlCommand(), + adapter.isExecSql() + )) { + + final DBSQLObject currentObject = (DBSQLObject) obj.getUnderlyingDbObject(); + st.execute(MessageFormat.format( + "DROP DOMAIN IF EXISTS {0}.{1} RESTRICT", + adapter.escapeNameIfNeeded(getPhisicalSchema(currentObject.getSchema())), + adapter.escapeNameIfNeeded(currentObject.getName()) + )); + + } catch (Exception e) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "objectRemoveError") + .withParams(obj.getName()), e); + } + } + + private String getDdlEscaped(DBSQLObject dbsqlObject) { + String query = dbsqlObject.getSql(); + final String name = dbsqlObject.getName(); + final String schema = dbsqlObject.getSchema(); + final String nameEscaped = adapter.escapeNameIfNeeded(name); + final String schemaEscaped = adapter.escapeNameIfNeeded(schema); + + if (! name.equalsIgnoreCase(nameEscaped)) { + query = query.replace( + "CREATE DOMAIN " + schema + "." + name, + "CREATE DOMAIN " + schemaEscaped + "." + nameEscaped + ); + } + if (! query.endsWith(";")) query = query + ";\n"; + query = query + "\n"; + return query; + } + + private String getChangeOwnerDdl(DBSQLObject dbsqlObject, String owner) { + return MessageFormat.format("ALTER TYPE {0}.{1} OWNER TO {2}\n" + , adapter.escapeNameIfNeeded(dbsqlObject.getSchema()) + , adapter.escapeNameIfNeeded(dbsqlObject.getName()) + , owner + ); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreEnumPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreEnumPostgres.java index cccbd38..f781be4 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreEnumPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreEnumPostgres.java @@ -1,17 +1,112 @@ package ru.fusionsoft.dbgit.postgres; +import java.sql.Connection; +import java.text.MessageFormat; +import java.util.Arrays; +import java.util.List; +import java.util.Map; import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.core.NotImplementedExceptionDBGitRuntime; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; +import ru.fusionsoft.dbgit.core.ExceptionDBGit; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBEnum; +import ru.fusionsoft.dbgit.dbobjects.DBSQLObject; import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaEnum; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; public class DBRestoreEnumPostgres extends DBRestoreAdapter { @Override public final boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - throw new NotImplementedExceptionDBGitRuntime(); + final IDBAdapter adapter = getAdapter(); + final Connection connect = adapter.getConnection(); + try (StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql())) { + if (! ( obj instanceof MetaEnum )) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "metaTypeError") + .withParams(obj.getName(), "enum", obj.getType().getValue()) + ); + } + final DBSQLObject restoreEnum = (DBSQLObject) obj.getUnderlyingDbObject(); + final Map enums = adapter.getEnums(restoreEnum.getSchema()); + + if(enums.containsKey(restoreEnum.getName())) { + DBEnum currentEnum = enums.get(restoreEnum.getName()); + if( + ! restoreEnum.getOptions().get("elements").equals( + currentEnum.getOptions().get("elements") + ) + ) { + st.execute(MessageFormat.format( + "ALTER TYPE {0}.{1} RENAME TO _deprecated_{1};\n{2}", + currentEnum.getSchema(), currentEnum.getName(), getDdlEscaped(restoreEnum) + )); + } else{ + if (! DBGitConfig.getInstance().getToIgnoreOnwer(false)) { + st.execute(getChangeOwnerDdl(currentEnum, restoreEnum.getOwner())); + } + } + } else { + st.execute(getDdlEscaped(restoreEnum)); + } + + } catch (Exception e) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), + e + ); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + return true; } @Override - public final void removeMetaObject(IMetaObject obj) throws Exception { - throw new NotImplementedExceptionDBGitRuntime(); + public void removeMetaObject(IMetaObject obj) throws Exception { + IDBAdapter adapter = getAdapter(); + Connection connect = adapter.getConnection(); + + try (StatementLogging st = new StatementLogging(connect, adapter.getStreamOutputSqlCommand(), adapter.isExecSql())){ + + final DBSQLObject currentObject = (DBSQLObject) obj.getUnderlyingDbObject(); + st.execute(MessageFormat.format( + "DROP TYPE {0}.{1}", + adapter.escapeNameIfNeeded(getPhisicalSchema(currentObject.getSchema())), + adapter.escapeNameIfNeeded(currentObject.getName()) + )); + + } catch (Exception e) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "objectRemoveError") + .withParams(obj.getName()), e); + } + } + + private String getDdlEscaped(DBSQLObject dbsqlObject) { + String query = dbsqlObject.getSql(); + final String name = dbsqlObject.getName(); + final String schema = dbsqlObject.getSchema(); + final String nameEscaped = adapter.escapeNameIfNeeded(name); + final String schemaEscaped = adapter.escapeNameIfNeeded(schema); + + if (! name.equalsIgnoreCase(nameEscaped)) { + query = query.replace( + "CREATE TYPE " + schema + "." + name, + "CREATE TYPE " + schemaEscaped + "." + nameEscaped + ); + } + if (! query.endsWith(";")) query = query + ";\n"; + query = query + "\n"; + return query; + } + + private String getChangeOwnerDdl(DBSQLObject dbsqlObject, String owner) { + return MessageFormat.format("ALTER TYPE {0}.{1} OWNER TO {2}\n" + , adapter.escapeNameIfNeeded(dbsqlObject.getSchema()) + , adapter.escapeNameIfNeeded(dbsqlObject.getName()) + , owner + ); } } diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java index 3627acc..a7ff235 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreTablePostgres.java @@ -324,6 +324,8 @@ private void restoreTableFields(MetaTable restoreTable, MetaTable existingTable, &&(restoreField.getTypeUniversal() != FieldType.BOOLEAN) &&(existingField.getTypeUniversal() != FieldType.STRING_NATIVE) &&(restoreField.getTypeUniversal() != FieldType.STRING_NATIVE) + &&(existingField.getTypeUniversal() != FieldType.NATIVE) + &&(restoreField.getTypeUniversal() != FieldType.NATIVE) && hasNotTypeSql(tblField, "json") && hasNotTypeSql(tblField, "text[]") && hasNotTypeSql(tblField, "text") diff --git a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUDTPostgres.java b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUDTPostgres.java index 9190a16..14e206c 100644 --- a/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUDTPostgres.java +++ b/src/main/java/ru/fusionsoft/dbgit/postgres/DBRestoreUDTPostgres.java @@ -1,17 +1,117 @@ package ru.fusionsoft.dbgit.postgres; +import java.sql.Connection; +import java.text.MessageFormat; +import java.util.Map; import ru.fusionsoft.dbgit.adapters.DBRestoreAdapter; -import ru.fusionsoft.dbgit.core.NotImplementedExceptionDBGitRuntime; +import ru.fusionsoft.dbgit.adapters.IDBAdapter; +import ru.fusionsoft.dbgit.core.DBGitConfig; +import ru.fusionsoft.dbgit.core.ExceptionDBGitRestore; +import ru.fusionsoft.dbgit.dbobjects.DBSQLObject; +import ru.fusionsoft.dbgit.dbobjects.DBUserDefinedType; import ru.fusionsoft.dbgit.meta.IMetaObject; +import ru.fusionsoft.dbgit.meta.MetaUDT; +import ru.fusionsoft.dbgit.statement.StatementLogging; +import ru.fusionsoft.dbgit.utils.ConsoleWriter; public class DBRestoreUDTPostgres extends DBRestoreAdapter { @Override public final boolean restoreMetaObject(IMetaObject obj, int step) throws Exception { - throw new NotImplementedExceptionDBGitRuntime(); + final IDBAdapter adapter = getAdapter(); + final Connection connect = adapter.getConnection(); + try (final StatementLogging st = new StatementLogging( + connect, + adapter.getStreamOutputSqlCommand(), + adapter.isExecSql() + )) { + if (! ( obj instanceof MetaUDT )) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "metaTypeError").withParams(obj.getName(), "udt", obj.getType().getValue()) + ); + } + final DBSQLObject restoreUDT = (DBSQLObject) obj.getUnderlyingDbObject(); + final Map udts = adapter.getUDTs(restoreUDT.getSchema()); + + if (udts.containsKey(restoreUDT.getName())) { + final DBUserDefinedType currentUDT = udts.get(restoreUDT.getName()); + if ( + ! restoreUDT.getOptions().get("attributes").equals( + currentUDT.getOptions().get("attributes") + ) + ) { + st.execute(MessageFormat.format( + "ALTER TYPE {0}.{1} RENAME TO _deprecated_{1};\n" + + "{2}", + currentUDT.getSchema(), currentUDT.getName(), getDdlEscaped(restoreUDT) + )); + } else { + if (! DBGitConfig.getInstance().getToIgnoreOnwer(false)) { + st.execute(getChangeOwnerDdl(currentUDT, restoreUDT.getOwner())); + } + } + } else { + st.execute(getDdlEscaped(restoreUDT)); + } + + } catch (Exception e) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "objectRestoreError").withParams(obj.getName()), + e + ); + } finally { + ConsoleWriter.detailsPrintGreen(lang.getValue("general", "ok")); + } + return true; } @Override - public final void removeMetaObject(IMetaObject obj) throws Exception { - throw new NotImplementedExceptionDBGitRuntime(); + public void removeMetaObject(IMetaObject obj) throws Exception { + final IDBAdapter adapter = getAdapter(); + final Connection connect = adapter.getConnection(); + + try (StatementLogging st = new StatementLogging( + connect, + adapter.getStreamOutputSqlCommand(), + adapter.isExecSql() + )) { + + final DBSQLObject currentObject = (DBSQLObject) obj.getUnderlyingDbObject(); + st.execute(MessageFormat.format( + "DROP TYPE {0}.{1}", + adapter.escapeNameIfNeeded(getPhisicalSchema(currentObject.getSchema())), + adapter.escapeNameIfNeeded(currentObject.getName()) + )); + + } catch (Exception e) { + throw new ExceptionDBGitRestore( + lang.getValue("errors", "restore", "objectRemoveError") + .withParams(obj.getName()), e); + } + } + + private String getDdlEscaped(DBSQLObject dbsqlObject) { + String query = dbsqlObject.getSql(); + final String name = dbsqlObject.getName(); + final String schema = dbsqlObject.getSchema(); + final String nameEscaped = adapter.escapeNameIfNeeded(name); + final String schemaEscaped = adapter.escapeNameIfNeeded(schema); + + if (! name.equalsIgnoreCase(nameEscaped)) { + query = query.replace( + "CREATE TYPE " + schema + "." + name, + "CREATE TYPE " + schemaEscaped + "." + nameEscaped + ); + } + if (! query.endsWith(";")) query = query + ";\n"; + query = query + "\n"; + return query; + } + + private String getChangeOwnerDdl(DBSQLObject dbsqlObject, String owner) { + return MessageFormat.format("ALTER TYPE {0}.{1} OWNER TO {2}\n" + , adapter.escapeNameIfNeeded(dbsqlObject.getSchema()) + , adapter.escapeNameIfNeeded(dbsqlObject.getName()) + , owner + ); } } diff --git a/src/main/resources/lang/eng.yaml b/src/main/resources/lang/eng.yaml index 941d303..1a3e5db 100644 --- a/src/main/resources/lang/eng.yaml +++ b/src/main/resources/lang/eng.yaml @@ -73,6 +73,9 @@ general: restoreTrigger: Restoring trigger {0} ... restoreSeq: Restoring sequence {0} ... restoreSchema: Restoring schema {0} ... + restoreUDT: Restoring user defined type {0} ... + restoreEnum: Restoring enum {0} ... + restoreDomain: Restoring domain {0} ... restoreRole: Restoring role {0} ... restorePrc: Restoring procedure {0} ... restorePkg: Restoring package {0} ... diff --git a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java index a23293c..fdffffe 100644 --- a/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java +++ b/src/test/java/ru/fusionsoft/dbgit/integration/DbGitIntegrationTestBasic.java @@ -205,6 +205,12 @@ public final void dbToFilesDumpWorks() { (path) -> { return path.resolve(".dbgit/public/year.domain").toFile().exists(); } + ), + new SimpleTest<>( + "film_summary.udt exists", + (path) -> { + return path.resolve(".dbgit/public/film_summary.udt").toFile().exists(); + } ) ); @@ -308,7 +314,7 @@ public final void dbToDbRestoreWorksWithCustomTypes() { //pagilla to local repo new PathAfterDbGitLinkAndAdd( new ArgsDbGitLinkPgAuto("pagilla"), - new CharsDbIgnoreWithTableData(), + new CharsDbIgnoreWithDataAndTypes(), //dvdrental to test#databasegit new PathAfterDbGitRun( @@ -320,7 +326,7 @@ public final void dbToDbRestoreWorksWithCustomTypes() { //dvdrental to local repo new PathAfterDbGitLinkAndAdd( new ArgsDbGitLinkPgAuto("dvdrental"), - new CharsDbIgnoreWithTableData(), + new CharsDbIgnoreWithDataAndTypes(), new PathAfterDbGitRun( new ArgsExplicit("init"),