Public

<init>

addToDroppedFKConstraints

appendFields

check and set whether this JVM is already setup to use pre GFXD 1.3.0.2 table
hashing or else if it 

checkAndSetPre1302HashingForTables

Returns if the DDL command is to be persisted on HDFS.

checkifHDFSPersistent

defaultPersistent

fromDataBase

fromDataPre_GFXD_1_0_1_1

getAdditionalArgs

getConstraintName

getCurrentSchema

getDroppedFKConstraints

getHDFSStoreName

getId

getImplicitSchema

getImplicitSchemaSequenceId

getKeyToConflate

getRegionToConflate

getSchemaForTable

getTableName

BufferedReader

Updating database using SQL prepared statement

A border layout lays out a container, arranging and resizing its components to
fit in five regions: 

java.awt.BorderLayout

A BufferedInputStream adds functionality to another input stream-namely, the
ability to buffer the i

java.io.BufferedInputStream

A readable source of bytes.Most clients will use input streams that read data
from the file system (

java.io.InputStream

A thread is a thread of execution in a program. The Java Virtual Machine allows
an application to ha

java.lang.Thread

Breaks a string into tokens; new code should probably use String#split.>  
// Legacy code: 
StringTo

java.util.StringTokenizer

Timers schedule one-shot or recurring TimerTask for execution. Prefer
java.util.concurrent.Scheduled

java.util.Timer

Return the contained value, if present, otherwise throw an exception to be
created by the provided s

orElseThrow

notifyDataSetChanged

setScale

// set the default schema masquerading as the user

"sqlText=%s and skipRegionInitialization=%s"

"FabricDatabase: SQL warning in initial replay of DDL: "

// #48232: ignore the exception, the schema may have been 

//#50116: ignore drop FK constraint since we may  

//not create it during DDL replay (since parent 

// If the ddl replay for the hive meta tables is in progress

// whatever may be the logging level, just log the warning messages.

// This is because hive meta store table replay generates hundreds of

// line of logs which are of no use. Once the hive meta tables are

// Wait for initial DDL replay to complete in case last round in progress

// If we were going to skip this execution then check for special cases of

// CREATE + DROP/ALTER combos first and see if CREATE has already been

// completed or is in the process of being executed

// check if this is a conflatable then in that case try conflation and if

// not possible due to execution in progress, then wait for DDL replay to

// try to conflate items from queue and wait for any executing conflated

// entries; if any of the entries to be conflated has been executed and

// this DDL has not been executed, then wait for entire DDL replay to

// now we have to wait for entire DDL replay to complete

// if we do not need to wait for DDL replay, then conflate the

// queue and add this to processed IDs set

// for ALTER TABLE we have to always wait for DDL replay to complete

// since we cannot pre-conflate the queue if CREATE is not done like

// ok, we do need to wait for DDL replay to complete;

// if DDL replay has reached the last iteration and is waiting

// for DD read lock, then skip wait on DD read lock by the node

// replay thread, if any, otherwise it can lead to a deadlock

// (#47873); this DDL message execution means that DD write lock is

// already held by the source node and the purpose of not allowing

// any more DDLs to come in by the DD read lock in replay thread is

// its possible that this DDL has been executed in replay

// Initial replay still in progress so just skip processing this message

// which will be later handled by replay; this breaks the behaviour of

// GfxdDDLMessage somewhat since a successful reply is sent without the

// DDL still having being executed but should have no improper behaviour

// as such; if we block, then DDLs on all processes will block till the

// initial replay of this VM is complete which is not desirable.

// store in pending message list in any case since put in DDL region

// will need to be done if origin node goes down before finish message

// indicates that this node should not execute anything in finish

// message or if origin node goes down before finish message

"skipping DDL execution due to replay in progress"

// skip DDL execution on locators/agents/admins

// With the new logic of not allowing new ddls to be fired when replay is

// going on the skipping logic is removed and instead an assertion is put

// that ddl replay should not be in progress when ddl is received.

// Commenting ou the below code because with the simplified ddl replay logic

// during restart we are taking dd read lock so on the fly ddl won't even reach here.

/*
    if (isOKToSkip(ddlId)) {
      boolean skipDDL = true;
      // check if this is a conflatable then in that case try conflation and if
      // not possible due to execution in progress, then wait for DDL replay to
      // be complete
      final boolean conflate = ddl.shouldBeConflated();
      if (conflate || ddl.shouldDelayRegionInitialization()) {
        // try to conflate items from queue and wait for any executing conflated
        // entries; if any of the entries to be conflated has been executed and
        // this DDL has not been executed, then wait for entire DDL replay to
        // be complete
        final GfxdDDLRegionQueue ddlQ = memStore.getDDLQueueNoThrow();
        if (ddlQ != null) {
          if (conflate) {
            ArrayList<QueueValue> conflatedItems = new ArrayList<QueueValue>(5);
            memStore.acquireDDLReplayLock(true);
            try {
              if (ddlQ.conflate(ddl, ddl, false, conflatedItems)) {
                for (QueueValue qValue : conflatedItems) {
                  final DDLConflatable confVal = (DDLConflatable)qValue
                      .getValue();
                  if (confVal.isExecuting()) {
                    // now we have to wait for entire DDL replay to complete
                    // to maintain the order of DDLs
                    skipDDL = false;
                    break;
                  }
                }
              }
              // if we do not need to wait for DDL replay, then conflate the
              // queue and add this to processed IDs set
              if (skipDDL && ddlQ.conflate(ddl, ddl, true, null)) {
                final TLongHashSet processedIds = memStore.getProcessedDDLIDs();
                synchronized (processedIds) {
                  processedIds.add(ddlId);
                }
              }
            } finally {
              memStore.releaseDDLReplayLock(true);
            }
          }
          else {
            // for ALTER TABLE we have to always wait for DDL replay to complete
            // since we cannot pre-conflate the queue if CREATE is not done like
            // for DROP
            skipDDL = false;
          }
          if (!skipDDL) {
            // ok, we do need to wait for DDL replay to complete;
            // if DDL replay has reached the last iteration and is waiting
            // for DD read lock, then skip wait on DD read lock by the node
            // replay thread, if any, otherwise it can lead to a deadlock
            // (#47873); this DDL message execution means that DD write lock is
            // already held by the source node and the purpose of not allowing
            // any more DDLs to come in by the DD read lock in replay thread is
            // already served
            memStore.setInitialDDLReplayWaiting(true);
            try {
              GemFireXDUtils.waitForNodeInitialization();
            } finally {
              memStore.setInitialDDLReplayWaiting(false);
            }
            // its possible that this DDL has been executed in replay
            // by this time, so check again
            final TLongHashSet processedIds = memStore.getProcessedDDLIDs();
            synchronized (processedIds) {
              skipDDL = processedIds.contains(ddlId);
            }
          }
        }
      }
      if (skipDDL) {
        SanityManager.DEBUG_PRINT(GfxdConstants.TRACE_DDLREPLAY, toString()
            + " Skipping execution of " + ddl.getValueToConflate()
            + " due to replay in progress");
        // Initial replay still in progress so just skip processing this message
        // which will be later handled by replay; this breaks the behaviour of
        // GfxdDDLMessage somewhat since a successful reply is sent without the
        // DDL still having being executed but should have no improper behaviour
        // as such; if we block, then DDLs on all processes will block till the
        // initial replay of this VM is complete which is not desirable.

        // store in pending message list in any case since put in DDL region
        // will need to be done if origin node goes down before finish message
        synchronized (pendingDDLMessages) {
          // indicates that this node should not execute anything in finish
          // message or if origin node goes down before finish message
          this.args.connId = EmbedConnection.UNINITIALIZED;
          pendingDDLMessages.put(ddlId, this);
        }
        throw new GfxdDDLReplayInProgressException(
            "skipping DDL execution due to replay in progress");
      }
    }
*/

// skip DDL execution on locators/agents/admins (not for HiveMetaTable

// set the context object from additional args, if any

"GfxdDDLMessage: Persisting statement on HDFS: "

// Find out all the HDFS stores where this ddl belongs

// Log a severe log in case of an unexpected exception

// need to explicitly rollback since autocommit is false by default

// and we do not want to come back to this VM again to rollback

// add self as the pending message to handle sender failure before

How to use defaultPersistentmethodin com.pivotal.gemfirexd.internal.engine.ddl.DDLConflatable

Best Java code snippets using com.pivotal.gemfirexd.internal.engine.ddl.DDLConflatable.defaultPersistent (Showing top 6 results out of 315)

How to use
defaultPersistent
method
in
com.pivotal.gemfirexd.internal.engine.ddl.DDLConflatable