/** * Get a BigDecimal representing the value of a DataValueDescriptor * * @param value Non-null value to be converted * @return BigDecimal value * @throws StandardException Invalid conversion or out of range. */ public static BigDecimal getBigDecimal(DataValueDescriptor value) throws StandardException { if (SanityManager.DEBUG) { if (value.isNull()) SanityManager.THROWASSERT("NULL value passed to SQLDecimal.getBigDecimal"); } switch (value.typeToBigDecimal()) { case Types.DECIMAL: return (BigDecimal) value.getObject(); case Types.CHAR: try { return new BigDecimal(value.getString().trim()); } catch (NumberFormatException nfe) { throw StandardException.newException( SQLState.LANG_FORMAT_EXCEPTION, "java.math.BigDecimal"); } case Types.BIGINT: return BigDecimal.valueOf(value.getLong()); default: if (SanityManager.DEBUG) SanityManager.THROWASSERT( "invalid return from " + value.getClass() + ".typeToBigDecimal() " + value.typeToBigDecimal()); return null; } }
/** * Write this object to a stream of stored objects. * * @param out write bytes here. * @exception IOException thrown on error */ public void writeExternal(ObjectOutput out) throws IOException { if (SanityManager.DEBUG) { SanityManager.ASSERT(triggerSchemaId != null, "triggerSchemaId expected to be non-null"); SanityManager.ASSERT(triggerTableId != null, "triggerTableId expected to be non-null"); } out.writeObject(id); out.writeObject(name); out.writeObject(triggerSchemaId); out.writeObject(triggerTableId); out.writeInt(eventMask); out.writeBoolean(isBefore); out.writeBoolean(isRow); out.writeBoolean(isEnabled); out.writeObject(whenSPSId); out.writeObject(actionSPSId); if (referencedCols == null) { out.writeInt(0); } else { out.writeInt(referencedCols.length); for (int i = 0; i < referencedCols.length; i++) { out.writeInt(referencedCols[i]); } } out.writeObject(triggerDefinition); out.writeBoolean(referencingOld); out.writeBoolean(referencingNew); out.writeObject(oldReferencingName); out.writeObject(newReferencingName); }
/** * Constructor * * @param activation The activation * @param source Source result set * @param rowAllocator * @param resultSetNumber The resultSetNumber * @param erdNumber Int for ResultDescription (so it can be turned back into an object) * @param restriction Restriction * @param optimizerEstimatedRowCount The optimizer's estimated number of rows. * @param optimizerEstimatedCost The optimizer's estimated cost */ WindowResultSet( Activation activation, NoPutResultSet source, int rowAllocator, int resultSetNumber, int erdNumber, GeneratedMethod restriction, double optimizerEstimatedRowCount, double optimizerEstimatedCost) throws StandardException { super(activation, resultSetNumber, optimizerEstimatedRowCount, optimizerEstimatedCost); if (SanityManager.DEBUG) { SanityManager.ASSERT(activation != null, "activation expected to be non-null"); SanityManager.ASSERT(resultSetNumber >= 0, "resultSetNumber expected to be >= 0"); } this.restriction = restriction; this.source = source; this.rownumber = 0; ExecPreparedStatement ps = activation.getPreparedStatement(); this.allocatedRow = ((ExecRowBuilder) ps.getSavedObject(rowAllocator)).build(activation.getExecutionFactory()); if (erdNumber != -1) { this.referencedColumns = (FormatableBitSet) ps.getSavedObject(erdNumber); } recordConstructorTime(); }
/** * restore the before image of the page * * @exception StandardException Standard Derby Error Policy * @exception IOException problem reading the complete log record from the input stream */ public void restoreMe( Transaction xact, BasePage undoPage, LogInstant CLRInstant, LimitObjectInput in) throws StandardException, IOException { int slot = undoPage.findRecordById(recordId, Page.FIRST_SLOT_NUMBER); if (SanityManager.DEBUG) { if (!getPageId().equals(undoPage.getPageId())) SanityManager.THROWASSERT( "restoreMe cannot restore to a different page. " + "doMe page:" + getPageId() + " undoPage:" + undoPage.getPageId()); if (slot != doMeSlot) SanityManager.THROWASSERT( "restoreMe cannot restore to a different slot. " + "doMe slot:" + doMeSlot + " undoMe slot: " + slot + " recordId:" + recordId); } undoPage.skipField(in); // skip the after image of the column undoPage.storeField(CLRInstant, slot, fieldId, in); undoPage.setAuxObject(null); }
/** * Restore field to its old value. * * @exception IOException Can be thrown by any of the methods of ObjectInput. * @exception StandardException Standard Derby policy. * @see LogicalPageOperation#undoMe */ public void undoMe( Transaction xact, BasePage undoPage, int undoRecordId, LogInstant CLRInstant, LimitObjectInput in) throws StandardException, IOException { int slot = undoPage.findRecordById(undoRecordId, Page.FIRST_SLOT_NUMBER); if (SanityManager.DEBUG) { // if the record Id has changed, the page had better changed // this can only happen during recovery since in run time undo, // this resetRecordHandle gets called and this object have the new // page number and recordId if (undoRecordId != this.recordId) if (undoPage.getPageNumber() == getPageId().getPageNumber()) SanityManager.THROWASSERT( "recordId changed from " + this.recordId + " to " + undoRecordId + " but page number did not change " + undoPage.getPageNumber()); if (slot == -1) SanityManager.THROWASSERT( "recordId " + undoRecordId + " not found on page " + undoPage.getPageNumber()); } undoPage.skipField((java.io.ObjectInput) in); // skip the after image of the column undoPage.storeField(CLRInstant, slot, fieldId, in); undoPage.setAuxObject(null); }
/** * Write the old column value and and new column value as optional data. If logical undo, writes * out the entire row's before image. * * @exception IOException Can be thrown by any of the methods of ObjectOutput. * @exception StandardException Standard Derby policy. */ private void writeOptionalDataToBuffer(RawTransaction t, Object column) throws StandardException, IOException { if (SanityManager.DEBUG) { SanityManager.ASSERT(this.page != null); } DynamicByteArrayOutputStream logBuffer = t.getLogBuffer(); int optionalDataStart = logBuffer.getPosition(); if (SanityManager.DEBUG) { SanityManager.ASSERT( optionalDataStart == 0, "Buffer for writing optional data should start at position 0"); } this.page.logColumn(doMeSlot, fieldId, column, logBuffer, 100); // the after image of the column this.page.logField(doMeSlot, fieldId, logBuffer); // the BI of the column if (undo != null) { // RESOLVE: we want the AFTER image of the row, not the BEFORE // image. This works for now because only btree needs a logical // undoable updateField and it always update only the pointer field // to point to something else. // // But in the future, it needs to be changed. this.page.logRecord( doMeSlot, BasePage.LOG_RECORD_DEFAULT, recordId, (FormatableBitSet) null, logBuffer, (RecordHandle) null); // log the BI of the entire row } int optionalDataLength = logBuffer.getPosition() - optionalDataStart; if (SanityManager.DEBUG) { if (optionalDataLength != logBuffer.getUsed()) SanityManager.THROWASSERT( "wrong optional data length, optionalDataLength = " + optionalDataLength + ", logBuffer.getUsed() = " + logBuffer.getUsed()); } // set the position to the beginning of the buffer logBuffer.setPosition(optionalDataStart); this.preparedLog = new ByteArray(logBuffer.getByteArray(), optionalDataStart, optionalDataLength); }
/** * Create a new item and set the identity of the object to represent it. The object will be in the * No Identity state, ie. it will have just been created or clearIdentity() was just called. <br> * The object must copy the information out of key, not just store a reference to key. After this * call the expression getIdentity().equals(key) must return true. <br> * If the class of the object needs to change (e.g. to support a different format) then the object * should create a new object, call its initParameter() with the parameters the original object * was called with, set its identity and return a reference to it. The cache manager will discard * the reference to the old object. <br> * If an exception is thrown the object must be left in the no-identity state. <br> * MT - single thread required - Method must only be called be cache manager and the cache manager * will guarantee only one thread can be calling it. * * @return an object reference if the object can take on the identity, null otherwise. * @exception StandardException If forCreate is true and the object cannot be created. * @see org.apache.derby.iapi.services.cache.CacheManager#create */ public Cacheable createIdentity(Object key, Object createParameter) throws StandardException { if (SanityManager.DEBUG) { SanityManager.ASSERT(key instanceof Long, "key is not instanceof Long"); SanityManager.ASSERT( createParameter instanceof Conglomerate, "createParameter is not instanceof Conglomerate"); } this.conglomid = (Long) key; this.conglom = ((Conglomerate) createParameter); return (this); }
/** * Restore the in-memory representation from the stream. * * <p> * * @exception ClassNotFoundException Thrown if the stored representation is serialized and a class * named in the stream could not be found. * @see java.io.Externalizable#readExternal */ private final void localReadExternal(ObjectInput in) throws IOException, ClassNotFoundException { super.readExternal(in); baseConglomerateId = in.readLong(); rowLocationColumn = in.readInt(); // read the column sort order info FormatableBitSet ascDescBits = new FormatableBitSet(); ascDescBits.readExternal(in); ascDescInfo = new boolean[ascDescBits.getLength()]; for (int i = 0; i < ascDescBits.getLength(); i++) ascDescInfo[i] = ascDescBits.isSet(i); // In memory maintain a collation id per column in the template. collation_ids = new int[format_ids.length]; if (SanityManager.DEBUG) { SanityManager.ASSERT(!hasCollatedTypes); } // initialize all the entries to COLLATION_TYPE_UCS_BASIC, // and then reset as necessary. For version ACCESS_B2I_V3_ID, // this is the default and no resetting is necessary. for (int i = 0; i < format_ids.length; i++) collation_ids[i] = StringDataValue.COLLATION_TYPE_UCS_BASIC; // initialize the unique with null setting to false, to be reset // below when read from disk. For version ACCESS_B2I_V3_ID and // ACCESS_B2I_V4_ID, this is the default and no resetting is necessary. setUniqueWithDuplicateNulls(false); if (conglom_format_id == StoredFormatIds.ACCESS_B2I_V4_ID || conglom_format_id == StoredFormatIds.ACCESS_B2I_V5_ID) { // current format id, read collation info from disk if (SanityManager.DEBUG) { // length must include row location column and at least // one other field. SanityManager.ASSERT(collation_ids.length >= 2, "length = " + collation_ids.length); } hasCollatedTypes = ConglomerateUtil.readCollationIdArray(collation_ids, in); } else if (conglom_format_id != StoredFormatIds.ACCESS_B2I_V3_ID) { // Currently only V3, V4 and V5 should be possible in a Derby DB. // Actual work for V3 is handled by default code above, so no // special work is necessary. if (SanityManager.DEBUG) { SanityManager.THROWASSERT("Unexpected format id: " + conglom_format_id); } } if (conglom_format_id == StoredFormatIds.ACCESS_B2I_V5_ID) { setUniqueWithDuplicateNulls(in.readBoolean()); } }
/** * Distill the BigDecimal to a byte array and write out: * * <UL> * <LI>scale (zero or positive) as a byte * <LI>length of byte array as a byte * <LI>the byte array * </UL> */ public void writeExternal(ObjectOutput out) throws IOException { // never called when value is null if (SanityManager.DEBUG) SanityManager.ASSERT(!isNull()); int scale; byte[] byteArray; if (value != null) { scale = value.scale(); // J2SE 5.0 introduced negative scale value for BigDecimals. // In previouse Java releases a negative scale was not allowed // (threw an exception on setScale and the constructor that took // a scale). // // Thus the Derby format for DECIMAL implictly assumed a // positive or zero scale value, and thus now must explicitly // be positive. This is to allow databases created under J2SE 5.0 // to continue to be supported under JDK 1.3/JDK 1.4, ie. to continue // the platform independence, independent of OS/cpu and JVM. // // If the scale is negative set the scale to be zero, this results // in an unchanged value with a new scale. A BigDecimal with a // negative scale by definition is a whole number. // e.g. 1000 can be represented by: // a BigDecimal with scale -3 (unscaled value of 1) // or a BigDecimal with scale 0 (unscaled value of 1000) if (scale < 0) { scale = 0; value = value.setScale(0); } BigInteger bi = value.unscaledValue(); byteArray = bi.toByteArray(); } else { scale = rawScale; byteArray = rawData; } if (SanityManager.DEBUG) { if (scale < 0) SanityManager.THROWASSERT( "DECIMAL scale at writeExternal is negative " + scale + " value " + toString()); } out.writeByte(scale); out.writeByte(byteArray.length); out.write(byteArray); }
/** * Insert rows while we keep getting duplicates from the merge run whose scan is in the open scan * array entry indexed by scanindex. */ void mergeARow(int scanindex) throws StandardException { if (SanityManager.DEBUG) { // Unless there's a bug, the scan index will refer // to an open scan. That's because we never put // a scan index for a closed scan into the sort // buffer (via setNextAux). SanityManager.ASSERT(openScans[scanindex] != null); } DataValueDescriptor[] row; // Read rows from the merge run and stuff them into the // sort buffer for as long as we encounter duplicates. do { row = sortObserver.getArrayClone(); // Fetch the row from the merge run. if (!openScans[scanindex].fetchNext(row)) { // If we're out of rows in the merge run, close the scan. openScans[scanindex].close(); openScans[scanindex] = null; return; } // Save the index of this merge run with // the row we're putting in the sort buffer. sortBuffer.setNextAux(scanindex); } while (sortBuffer.insert(row) == SortBuffer.INSERT_DUPLICATE); }
/** @see TypeCompiler#getCastToCharWidth */ public int getCastToCharWidth(DataTypeDescriptor dts) { int formatId = getStoredFormatIdFromTypeId(); switch (formatId) { case StoredFormatIds.DECIMAL_TYPE_ID: // Need to have space for '-' and decimal point. return dts.getPrecision() + 2; case StoredFormatIds.DOUBLE_TYPE_ID: return TypeCompiler.DOUBLE_MAXWIDTH_AS_CHAR; case StoredFormatIds.INT_TYPE_ID: return TypeCompiler.INT_MAXWIDTH_AS_CHAR; case StoredFormatIds.LONGINT_TYPE_ID: return TypeCompiler.LONGINT_MAXWIDTH_AS_CHAR; case StoredFormatIds.REAL_TYPE_ID: return TypeCompiler.REAL_MAXWIDTH_AS_CHAR; case StoredFormatIds.SMALLINT_TYPE_ID: return TypeCompiler.SMALLINT_MAXWIDTH_AS_CHAR; case StoredFormatIds.TINYINT_TYPE_ID: return TypeCompiler.TINYINT_MAXWIDTH_AS_CHAR; default: if (SanityManager.DEBUG) { SanityManager.THROWASSERT("unexpected formatId in getCastToCharWidth() - " + formatId); } return 0; } }
synchronized void transfer(Object oldGroup, Object newGroup) { HashMap from = (HashMap) groups.get(oldGroup); if (from == null) return; HashMap to = (HashMap) groups.get(newGroup); if (to == null) { // simple case groups.put(newGroup, from); clearLimit(oldGroup); groups.remove(oldGroup); return; } if (to.size() < from.size()) { // place the contents of to into from mergeGroups(to, from); Object oldTo = groups.put(newGroup, from); if (SanityManager.DEBUG) { SanityManager.ASSERT(oldTo == to, "inconsistent state in LockSpace"); } } else { mergeGroups(from, to); } clearLimit(oldGroup); groups.remove(oldGroup); }
/** * Get the method name for getting out the corresponding primitive Java type. * * @return String The method call name for getting the corresponding primitive Java type. */ public String getPrimitiveMethodName() { if (SanityManager.DEBUG) { SanityManager.THROWASSERT( "getPrimitiveMethodName not applicable for " + getClass().toString()); } return null; }
/** @see TypeCompiler#getCorrespondingPrimitiveTypeName */ public String getCorrespondingPrimitiveTypeName() { /* Only numerics and booleans get mapped to Java primitives */ int formatId = getStoredFormatIdFromTypeId(); switch (formatId) { case StoredFormatIds.DOUBLE_TYPE_ID: return "double"; case StoredFormatIds.INT_TYPE_ID: return "int"; case StoredFormatIds.LONGINT_TYPE_ID: return "long"; case StoredFormatIds.REAL_TYPE_ID: return "float"; case StoredFormatIds.SMALLINT_TYPE_ID: return "short"; case StoredFormatIds.TINYINT_TYPE_ID: return "byte"; case StoredFormatIds.DECIMAL_TYPE_ID: default: if (SanityManager.DEBUG) { SanityManager.THROWASSERT( "unexpected formatId in getCorrespondingPrimitiveTypeName() - " + formatId); } return null; } }
/** * Get the method name for getting out the corresponding primitive Java type. * * @return String The method call name for getting the corresponding primitive Java type. */ public String getPrimitiveMethodName() { int formatId = getStoredFormatIdFromTypeId(); switch (formatId) { case StoredFormatIds.DOUBLE_TYPE_ID: return "getDouble"; case StoredFormatIds.INT_TYPE_ID: return "getInt"; case StoredFormatIds.LONGINT_TYPE_ID: return "getLong"; case StoredFormatIds.REAL_TYPE_ID: return "getFloat"; case StoredFormatIds.SMALLINT_TYPE_ID: return "getShort"; case StoredFormatIds.TINYINT_TYPE_ID: return "getByte"; case StoredFormatIds.DECIMAL_TYPE_ID: default: if (SanityManager.DEBUG) { SanityManager.THROWASSERT( "unexpected formatId in getPrimitiveMethodName() - " + formatId); } return null; } }
String nullMethodName() { int formatId = getStoredFormatIdFromTypeId(); switch (formatId) { case StoredFormatIds.DECIMAL_TYPE_ID: return "getNullDecimal"; case StoredFormatIds.DOUBLE_TYPE_ID: return "getNullDouble"; case StoredFormatIds.INT_TYPE_ID: return "getNullInteger"; case StoredFormatIds.LONGINT_TYPE_ID: return "getNullLong"; case StoredFormatIds.REAL_TYPE_ID: return "getNullFloat"; case StoredFormatIds.SMALLINT_TYPE_ID: return "getNullShort"; case StoredFormatIds.TINYINT_TYPE_ID: return "getNullByte"; default: if (SanityManager.DEBUG) { SanityManager.THROWASSERT("unexpected formatId in nullMethodName() - " + formatId); } return null; } }
/** * Make the ConstantAction for a CREATE TRIGGER statement. * * @param triggerSchemaName name for the schema that trigger lives in. * @param triggerName Name of trigger * @param eventMask TriggerDescriptor.TRIGGER_EVENT_XXXX * @param isBefore is this a before (as opposed to after) trigger * @param isRow is this a row trigger or statement trigger * @param isEnabled is this trigger enabled or disabled * @param triggerTable the table upon which this trigger is defined * @param whenSPSId the sps id for the when clause (may be null) * @param whenText the text of the when clause (may be null) * @param actionSPSId the spsid for the trigger action (may be null) * @param actionText the text of the trigger action * @param spsCompSchemaId the compilation schema for the action and when spses. If null, will be * set to the current default schema * @param creationTimestamp when was this trigger created? if null, will be set to the time that * executeConstantAction() is invoked * @param referencedCols what columns does this trigger reference (may be null) * @param originalActionText The original user text of the trigger action * @param referencingOld whether or not OLD appears in REFERENCING clause * @param referencingNew whether or not NEW appears in REFERENCING clause * @param oldReferencingName old referencing table name, if any, that appears in REFERENCING * clause * @param newReferencingName new referencing table name, if any, that appears in REFERENCING * clause */ CreateTriggerConstantAction( String triggerSchemaName, String triggerName, int eventMask, boolean isBefore, boolean isRow, boolean isEnabled, TableDescriptor triggerTable, UUID whenSPSId, String whenText, UUID actionSPSId, String actionText, UUID spsCompSchemaId, Timestamp creationTimestamp, int[] referencedCols, String originalActionText, boolean referencingOld, boolean referencingNew, String oldReferencingName, String newReferencingName) { super(triggerTable.getUUID()); this.triggerName = triggerName; this.triggerSchemaName = triggerSchemaName; this.triggerTable = triggerTable; this.eventMask = eventMask; this.isBefore = isBefore; this.isRow = isRow; this.isEnabled = isEnabled; this.whenSPSId = whenSPSId; this.whenText = whenText; this.actionSPSId = actionSPSId; this.actionText = actionText; this.spsCompSchemaId = spsCompSchemaId; this.creationTimestamp = creationTimestamp; this.referencedCols = referencedCols; this.originalActionText = originalActionText; this.referencingOld = referencingOld; this.referencingNew = referencingNew; this.oldReferencingName = oldReferencingName; this.newReferencingName = newReferencingName; if (SanityManager.DEBUG) { SanityManager.ASSERT(triggerSchemaName != null, "triggerSchemaName sd is null"); SanityManager.ASSERT(triggerName != null, "trigger name is null"); SanityManager.ASSERT(triggerTable != null, "triggerTable is null"); SanityManager.ASSERT(actionText != null, "actionText is null"); } }
/** * ************************************************************************ Protected concrete * impl of abstract methods of GenericConglomerateController class: * ************************************************************************* */ protected final void getRowPositionFromRowLocation(RowLocation row_loc, RowPosition pos) throws StandardException { if (SanityManager.DEBUG) { SanityManager.ASSERT(row_loc instanceof HeapRowLocation); } pos.current_rh = ((HeapRowLocation) row_loc).getRecordHandle(open_conglom.getContainer()); pos.current_rh_qualified = true; }
protected boolean lockRow(RecordHandle rh, int lock_oper, boolean wait, int lock_duration) throws StandardException { boolean ret_val; boolean forUpdate = ((ConglomerateController.LOCK_UPD & lock_oper) != 0); boolean forUpdateLock = ((ConglomerateController.LOCK_UPDATE_LOCKS & lock_oper) != 0); if (forUpdate && !forUpdateLock) { boolean forInsert = ((ConglomerateController.LOCK_INS & lock_oper) != 0); boolean forInsertPrevKey = ((ConglomerateController.LOCK_INS_PREVKEY & lock_oper) != 0); if (SanityManager.DEBUG) { SanityManager.ASSERT(!(forInsertPrevKey && forInsert)); } if (lock_duration == TransactionManager.LOCK_INSTANT_DURATION) { ret_val = open_conglom .getContainer() .getLockingPolicy() .zeroDurationLockRecordForWrite( open_conglom.getRawTran(), rh, forInsertPrevKey, wait); } else { ret_val = open_conglom .getContainer() .getLockingPolicy() .lockRecordForWrite(open_conglom.getRawTran(), rh, forInsert, wait); } } else { if (SanityManager.DEBUG) { SanityManager.ASSERT((ConglomerateController.LOCK_INS & lock_oper) == 0); SanityManager.ASSERT((ConglomerateController.LOCK_INS_PREVKEY & lock_oper) == 0); } ret_val = open_conglom .getContainer() .getLockingPolicy() .lockRecordForRead( open_conglom.getRawTran(), open_conglom.getContainer(), rh, wait, forUpdate); } return (ret_val); }
/** * Flatten this FSqry into the outer query block. The steps in flattening are: o Mark all * ResultColumns as redundant, so that they are "skipped over" at generate(). o Append the * wherePredicates to the outer list. o Return the fromList so that the caller will merge the 2 * lists RESOLVE - FSqrys with subqueries are currently not flattenable. Some of them can be * flattened, however. We need to merge the subquery list when we relax this restriction. * * <p>NOTE: This method returns NULL when flattening RowResultSetNodes (the node for a VALUES * clause). The reason is that no reference is left to the RowResultSetNode after flattening is * done - the expressions point directly to the ValueNodes in the RowResultSetNode's * ResultColumnList. * * @param rcl The RCL from the outer query * @param outerPList PredicateList to append wherePredicates to. * @param sql The SubqueryList from the outer query * @param gbl The group by list, if any * @param havingClause The HAVING clause, if any * @return FromList The fromList from the underlying SelectNode. * @exception StandardException Thrown on error */ public FromList flatten( ResultColumnList rcl, PredicateList outerPList, SubqueryList sql, GroupByList gbl, ValueNode havingClause) throws StandardException { FromList fromList = null; SelectNode selectNode; resultColumns.setRedundant(); subquery.getResultColumns().setRedundant(); /* ** RESOLVE: Each type of result set should know how to remap itself. */ if (subquery instanceof SelectNode) { selectNode = (SelectNode) subquery; fromList = selectNode.getFromList(); // selectNode.getResultColumns().setRedundant(); if (selectNode.getWherePredicates().size() > 0) { outerPList.destructiveAppend(selectNode.getWherePredicates()); } if (selectNode.getWhereSubquerys().size() > 0) { sql.destructiveAppend(selectNode.getWhereSubquerys()); } } else if (!(subquery instanceof RowResultSetNode)) { if (SanityManager.DEBUG) { SanityManager.THROWASSERT( "subquery expected to be either a SelectNode or a RowResultSetNode, but is a " + subquery.getClass().getName()); } } /* Remap all ColumnReferences from the outer query to this node. * (We replace those ColumnReferences with clones of the matching * expression in the SELECT's RCL. */ rcl.remapColumnReferencesToExpressions(); outerPList.remapColumnReferencesToExpressions(); if (gbl != null) { gbl.remapColumnReferencesToExpressions(); } if (havingClause != null) { havingClause.remapColumnReferencesToExpressions(); } return fromList; }
/** * Called when setting a DECIMAL value internally or from through a procedure or function. Handles * long in addition to BigDecimal to handle identity being stored as a long but returned as a * DECIMAL. */ public void setValue(Number theValue) throws StandardException { if (SanityManager.ASSERT) { if (theValue != null && !(theValue instanceof java.math.BigDecimal) && !(theValue instanceof java.lang.Long)) SanityManager.THROWASSERT("SQLDecimal.setValue(Number) passed a " + theValue.getClass()); } if (theValue instanceof BigDecimal || theValue == null) setCoreValue((BigDecimal) theValue); else setValue(theValue.longValue()); }
/** Initialize the scan, returning false if there was some error. */ public boolean init(TransactionManager tran) throws StandardException { if (SanityManager.DEBUG) { // We really expect to have at least one // merge run. SanityManager.ASSERT(mergeRuns != null); SanityManager.ASSERT(mergeRuns.size() > 0); // This sort scan also expects that the // caller has ensured that the sort buffer // capacity will hold a row from all the // merge runs. SanityManager.ASSERT(sortBuffer.capacity() >= mergeRuns.size()); } // Clear the sort buffer. sortBuffer.reset(); // Create an array to hold a scan controller // for each merge run. openScans = new StreamContainerHandle[mergeRuns.size()]; if (openScans == null) return false; // Open a scan on each merge run. int scanindex = 0; Enumeration e = mergeRuns.elements(); while (e.hasMoreElements()) { // get the container id long id = ((Long) e.nextElement()).longValue(); Transaction rawTran = tran.getRawStoreXact(); // get raw transaction int segmentId = StreamContainerHandle.TEMPORARY_SEGMENT; openScans[scanindex++] = rawTran.openStreamContainer(segmentId, id, hold); } // Load the initial rows. for (scanindex = 0; scanindex < openScans.length; scanindex++) mergeARow(scanindex); // Success! return true; }
/** Close the scan, a commit or abort is about to happen. */ public boolean closeForEndTransaction(boolean closeHeldScan) throws StandardException { boolean ret_val = super.closeForEndTransaction(closeHeldScan); if (SanityManager.DEBUG) SanityManager.ASSERT(ret_val, "B2IMaxScan never should be held across a commit."); if (base_cc_for_locking != null) { base_cc_for_locking.close(); base_cc_for_locking = null; } return (ret_val); }
/** * Get the constraint type out of the row. * * @param row The row from sysconstraints * @return int The constraint type as an int * @exception StandardException thrown on failure */ protected int getConstraintType(ExecRow row) throws StandardException { DataValueDescriptor col; int constraintIType; String constraintSType; /* 4th column is TYPE (char(1)) */ col = row.getColumn(SYSCONSTRAINTS_TYPE); constraintSType = col.getString(); if (SanityManager.DEBUG) { SanityManager.ASSERT(constraintSType.length() == 1, "Fourth column type incorrect"); } switch (constraintSType.charAt(0)) { case 'P': constraintIType = DataDictionary.PRIMARYKEY_CONSTRAINT; break; case 'U': constraintIType = DataDictionary.UNIQUE_CONSTRAINT; break; case 'C': constraintIType = DataDictionary.CHECK_CONSTRAINT; break; case 'F': constraintIType = DataDictionary.FOREIGNKEY_CONSTRAINT; break; default: if (SanityManager.DEBUG) { SanityManager.THROWASSERT("Fourth column value invalid"); } constraintIType = -1; } return constraintIType; }
/** * Reopen this ResultSet. * * @exception StandardException thrown if cursor finished. */ public void reopenCore() throws StandardException { if (SanityManager.DEBUG) { SanityManager.ASSERT(isOpen, "WindowResultSet already open"); } beginTime = getCurrentTimeMillis(); /* Reopen the source */ source.reopenCore(); rownumber = 0; numOpens++; openTime += getElapsedMillis(beginTime); }
public void insertAndFetchLocation(DataValueDescriptor[] row, RowLocation templateRowLocation) throws StandardException { if (open_conglom.isClosed()) { if (open_conglom.getHold()) { open_conglom.reopen(); } else { throw (StandardException.newException( SQLState.HEAP_IS_CLOSED, open_conglom.getConglomerate().getId())); } } RecordHandle rh = doInsert(row); if (SanityManager.DEBUG) { SanityManager.ASSERT(templateRowLocation instanceof HeapRowLocation); } HeapRowLocation hrl = (HeapRowLocation) templateRowLocation; hrl.setFrom(rh); }
/** * If the result set has been opened, close the open scan, else throw. * * @exception StandardException thrown on error */ public void close() throws StandardException { beginTime = getCurrentTimeMillis(); if (isOpen) { clearCurrentRow(); /* * Make sure to close the source */ source.close(); super.close(); } else if (SanityManager.DEBUG) { SanityManager.DEBUG("CloseRepeatInfo", "Close of WindowResultSet repeated"); } closeTime += getElapsedMillis(beginTime); }
/** * Initializer for a CreateTableNode for a base table * * @param newObjectName The name of the new object being created (ie base table) * @param tableElementList The elements of the table: columns, constraints, etc. * @param properties The optional list of properties associated with the table. * @param lockGranularity The lock granularity. * @exception StandardException Thrown on error */ public void init( Object newObjectName, Object tableElementList, Object properties, Object lockGranularity) throws StandardException { tableType = TableDescriptor.BASE_TABLE_TYPE; this.lockGranularity = ((Character) lockGranularity).charValue(); implicitCreateSchema = true; if (SanityManager.DEBUG) { if (this.lockGranularity != TableDescriptor.TABLE_LOCK_GRANULARITY && this.lockGranularity != TableDescriptor.ROW_LOCK_GRANULARITY) { SanityManager.THROWASSERT("Unexpected value for lockGranularity = " + this.lockGranularity); } } initAndCheck(newObjectName); this.tableElementList = (TableElementList) tableElementList; this.properties = (Properties) properties; }
/** * Find the container and then read the page from that container. * * <p>This is the way new pages enter the page cache. * * <p> * * @return always true, higher levels have already checked the page number is valid for an open. * @exception StandardException Standard Derby policy. * @see Cacheable#setIdentity */ public Cacheable setIdentity(Object key) throws StandardException { if (SanityManager.DEBUG) { SanityManager.ASSERT(key instanceof PageKey); } initialize(); PageKey newIdentity = (PageKey) key; FileContainer myContainer = (FileContainer) containerCache.find(newIdentity.getContainerId()); setContainerRowCount(myContainer.getEstimatedRowCount(0)); try { if (!alreadyReadPage) { // Fill in the pageData array by reading bytes from disk. readPage(myContainer, newIdentity); } else { // pageData array already filled alreadyReadPage = false; } // if the formatID on disk is not the same as this page instance's // format id, instantiate the real page object int fmtId = getTypeFormatId(); int onPageFormatId = FormatIdUtil.readFormatIdInteger(pageData); if (fmtId != onPageFormatId) { return changeInstanceTo(onPageFormatId, newIdentity).setIdentity(key); } // this is the correct page instance initFromData(myContainer, newIdentity); } finally { containerCache.release(myContainer); myContainer = null; } fillInIdentity(newIdentity); initialRowCount = 0; return this; }
private int getDefaultAccessLevel() throws StandardException { PersistentSet tc = lcc.getTransactionExecute(); String modeS = (String) PropertyUtil.getServiceProperty(tc, Property.DEFAULT_CONNECTION_MODE_PROPERTY); if (modeS == null) return FULL_ACCESS; else if (StringUtil.SQLEqualsIgnoreCase(modeS, Property.NO_ACCESS)) return NO_ACCESS; else if (StringUtil.SQLEqualsIgnoreCase(modeS, Property.READ_ONLY_ACCESS)) return READ_ACCESS; else if (StringUtil.SQLEqualsIgnoreCase(modeS, Property.FULL_ACCESS)) return FULL_ACCESS; else { if (SanityManager.DEBUG) SanityManager.THROWASSERT( "Invalid value for property " + Property.DEFAULT_CONNECTION_MODE_PROPERTY + " " + modeS); return FULL_ACCESS; } }