code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
protected void shutdown() throws InterruptedException {
if (m_deadConnectionFuture != null) {
m_deadConnectionFuture.cancel(false);
try {m_deadConnectionFuture.get();} catch (Throwable t) {}
}
if (m_topologyCheckFuture != null) {
m_topologyCheckFuture.cancel(false);
try {m_topologyCheckFuture.get();} catch (Throwable t) {}
}
if (m_maxConnectionUpdater != null) {
m_maxConnectionUpdater.cancel(false);
}
if (m_acceptor != null) {
m_acceptor.shutdown();
}
if (m_adminAcceptor != null)
{
m_adminAcceptor.shutdown();
}
if (m_snapshotDaemon != null) {
m_snapshotDaemon.shutdown();
}
if (m_migratePartitionLeaderExecutor != null) {
m_migratePartitionLeaderExecutor.shutdown();
}
m_notifier.shutdown();
} | java |
public void sendEOLMessage(int partitionId) {
final long initiatorHSId = m_cartographer.getHSIdForMaster(partitionId);
Iv2EndOfLogMessage message = new Iv2EndOfLogMessage(partitionId);
m_mailbox.send(initiatorHSId, message);
} | java |
private ClientResponseImpl getMispartitionedErrorResponse(StoredProcedureInvocation task,
Procedure catProc, Exception ex) {
Object invocationParameter = null;
try {
invocationParameter = task.getParameterAtIndex(catProc.getPartitionparameter());
} catch (Exception ex2) {
}
String exMsg = "Unknown";
if (ex != null) {
exMsg = ex.getMessage();
}
String errorMessage = "Error sending procedure " + task.getProcName()
+ " to the correct partition. Make sure parameter values are correct."
+ " Parameter value " + invocationParameter
+ ", partition column " + catProc.getPartitioncolumn().getName()
+ " type " + catProc.getPartitioncolumn().getType()
+ " Message: " + exMsg;
authLog.warn(errorMessage);
ClientResponseImpl clientResponse = new ClientResponseImpl(ClientResponse.UNEXPECTED_FAILURE,
new VoltTable[0], errorMessage, task.clientHandle);
return clientResponse;
} | java |
public boolean ceaseAllPublicFacingTrafficImmediately() {
try {
if (m_acceptor != null) {
// This call seems to block until the shutdown is done
// which is good becasue we assume there will be no new
// connections afterward
m_acceptor.shutdown();
}
if (m_adminAcceptor != null) {
m_adminAcceptor.shutdown();
}
}
catch (InterruptedException e) {
// this whole method is really a best effort kind of thing...
log.error(e);
// if we didn't succeed, let the caller know and take action
return false;
}
finally {
m_isAcceptingConnections.set(false);
// this feels like an unclean thing to do... but should work
// for the purposes of cutting all responses right before we deliberately
// end the process
// m_cihm itself is thread-safe, and the regular shutdown code won't
// care if it's empty... so... this.
m_cihm.clear();
}
return true;
} | java |
void processMigratePartitionLeaderTask(MigratePartitionLeaderMessage message) {
synchronized(m_lock) {
//start MigratePartitionLeader service
if (message.startMigratingPartitionLeaders()) {
if (m_migratePartitionLeaderExecutor == null) {
m_migratePartitionLeaderExecutor = Executors.newSingleThreadScheduledExecutor(CoreUtils.getThreadFactory("MigratePartitionLeader"));
final int interval = Integer.parseInt(System.getProperty("MIGRATE_PARTITION_LEADER_INTERVAL", "1"));
final int delay = Integer.parseInt(System.getProperty("MIGRATE_PARTITION_LEADER_DELAY", "1"));
m_migratePartitionLeaderExecutor.scheduleAtFixedRate(
() -> startMigratePartitionLeader(message.isForStopNode()),
delay, interval, TimeUnit.SECONDS);
}
hostLog.info("MigratePartitionLeader task is started.");
return;
}
//stop MigratePartitionLeader service
if (m_migratePartitionLeaderExecutor != null ) {
m_migratePartitionLeaderExecutor.shutdown();
m_migratePartitionLeaderExecutor = null;
}
}
hostLog.info("MigratePartitionLeader task is stopped.");
} | java |
public VoltTable[] run(SystemProcedureExecutionContext ctx) {
// Choose the lowest site ID on this host to actually flip the bit
VoltDBInterface voltdb = VoltDB.instance();
OperationMode opMode = voltdb.getMode();
if (ctx.isLowestSiteId()) {
ZooKeeper zk = voltdb.getHostMessenger().getZK();
try {
Stat stat;
OperationMode zkMode = null;
Code code;
do {
stat = new Stat();
code = Code.BADVERSION;
try {
byte [] data = zk.getData(VoltZK.operationMode, false, stat);
zkMode = data == null ? opMode : OperationMode.valueOf(data);
if (zkMode == RUNNING) {
break;
}
stat = zk.setData(VoltZK.operationMode, RUNNING.getBytes(), stat.getVersion());
code = Code.OK;
zkMode = RUNNING;
break;
} catch (BadVersionException ex) {
code = ex.code();
}
} while (zkMode != RUNNING && code == Code.BADVERSION);
m_stat = stat;
voltdb.getHostMessenger().unpause();
voltdb.setMode(RUNNING);
// for snmp
SnmpTrapSender snmp = voltdb.getSnmpTrapSender();
if (snmp != null) {
snmp.resume("Cluster resumed.");
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
VoltTable t = new VoltTable(VoltSystemProcedure.STATUS_SCHEMA);
t.addRow(VoltSystemProcedure.STATUS_OK);
return new VoltTable[] {t};
} | java |
private static File getNativeLibraryFile(String libname) {
// for now, arch is always x86_64
String pathFormat = "/org/voltdb/native/%s/x86_64";
String libPath = null;
String osName = System.getProperty("os.name").toLowerCase();
if (osName.contains("mac")) {
libPath = String.format(pathFormat, "Mac");
} else if (osName.contains("linux")) {
libPath = String.format(pathFormat, "Linux");
} else {
throw new RuntimeException("Unsupported system: " + osName);
}
String libFileName = System.mapLibraryName(libname);
if (NativeLibraryLoader.class.getResource(libPath + "/" + libFileName) == null) {
// mapLibraryName does not give us the correct name on mac sometimes
if (osName.contains("mac")) {
libFileName = "lib" + libname + ".jnilib";
}
if (NativeLibraryLoader.class.getResource(libPath + "/" + libFileName) == null) {
String msg = "Could not find library resource using path: " + libPath + "/" + libFileName;
s_hostLog.warn(msg);
throw new RuntimeException(msg);
}
}
File tmpFilePath = new File(System.getProperty(VOLT_TMP_DIR, System.getProperty("java.io.tmpdir")));
if (s_hostLog.isDebugEnabled()) {
s_hostLog.debug("Temp directory to which shared libs are extracted is: " + tmpFilePath.getAbsolutePath());
}
try {
return loadLibraryFile(libPath, libFileName, tmpFilePath.getAbsolutePath());
} catch(IOException e) {
s_hostLog.error("Error loading Volt library file from jar", e);
throw new RuntimeException(e);
}
} | java |
public static void writeString(String value, ByteBuffer buf) {
if (value == null) {
buf.putInt(VoltType.NULL_STRING_LENGTH);
return;
}
byte[] strbytes = value.getBytes(Constants.UTF8ENCODING);
int len = strbytes.length;
buf.putInt(len);
buf.put(strbytes);
} | java |
public static void writeVarbinary(byte[] bytes, ByteBuffer buf) throws IOException {
if (bytes == null) {
buf.putInt(VoltType.NULL_STRING_LENGTH);
return;
}
buf.putInt(bytes.length);
buf.put(bytes);
} | java |
private static long getMaxBidId(Client client) {
long currentMaxBidId = 0;
try {
VoltTable vt = client.callProcedure("@AdHoc", "select max(id) from bids").getResults()[0];
vt.advanceRow();
currentMaxBidId = vt.getLong(0);
if (vt.wasNull()) {
currentMaxBidId = 0;
}
} catch (IOException | ProcCallException e) {
e.printStackTrace();
}
return currentMaxBidId;
} | java |
@Override
public void run() {
long bidId = m_bidId++;
long advertiserId = Math.abs(m_rand.nextLong()) % NUM_ADVERTISERS;
GeographyValue bidRegion = Regions.pickRandomRegion();
TimestampType bidStartTime = new TimestampType();
TimestampType bidEndTime = new TimestampType(
bidStartTime.getTime() + AdBrokerBenchmark.BID_DURATION_SECONDS * 1000000);
// Amount of bid: a hundredth of a penny up to around a tenth of a penny.
double amount = 0.00001 + 0.01 * m_rand.nextDouble();
DecimalFormat df = new DecimalFormat("#.####");
amount = Double.valueOf(df.format(amount));
try {
m_client.callProcedure(new NullCallback(), "bids.Insert",
bidId,
advertiserId,
bidRegion,
bidStartTime,
bidEndTime,
amount);
} catch (Exception e) {
e.printStackTrace();
}
} | java |
String getName() {
int idx = mName.lastIndexOf('/');
return (idx > 0) ? mName.substring(idx) : mName;
} | java |
public AbstractExpression singlePartitioningExpression() {
AbstractExpression e = singlePartitioningExpressionForReport();
if (e != null && isUsefulPartitioningExpression(e)) {
return e;
}
return null;
} | java |
void analyzeTablePartitioning(Collection<StmtTableScan> collection)
throws PlanningErrorException
{
m_countOfPartitionedTables = 0;
// Do we have a need for a distributed scan at all?
// Iterate over the tables to collect partition columns.
for (StmtTableScan tableScan : collection) {
if ( ! tableScan.getIsReplicated()) {
++m_countOfPartitionedTables;
}
}
// Initial guess -- as if no equality filters.
m_countOfIndependentlyPartitionedTables = m_countOfPartitionedTables;
} | java |
public void resetAnalysisState() {
m_countOfIndependentlyPartitionedTables = -1;
m_countOfPartitionedTables = -1;
m_fullColumnName = null;
m_inferredExpression.clear();
m_inferredParameterIndex = -1;
m_inferredValue = null;
m_isDML = false;
setJoinValid(true);
setJoinInvalidReason(null);
m_partitionColForDML = null;
} | java |
public boolean callProcedure(Invocation invocation, ProcedureCallback callback)
{
try {
boolean result = m_importServerAdapter.callProcedure(this,
m_backPressurePredicate,
callback, invocation.getProcedure(), invocation.getParams());
reportStat(result, invocation.getProcedure());
return result;
} catch (Exception ex) {
rateLimitedLog(Level.ERROR, ex, "%s: Error trying to import", getName());
reportFailureStat(invocation.getProcedure());
return false;
}
} | java |
@Override
public void rateLimitedLog(Level level, Throwable cause, String format, Object... args)
{
m_logger.rateLimitedLog(LOG_SUPPRESSION_INTERVAL_SECONDS, level, cause, format, args);
} | java |
protected void trace(Throwable t, String msgFormat, Object... args)
{
m_logger.trace(String.format(msgFormat, args), t);
} | java |
@Override
public void warn(Throwable t, String msgFormat, Object... args)
{
m_logger.warn(String.format(msgFormat, args), t);
} | java |
public void add(Right right) {
if (isFull) {
return;
}
if (right.isFull) {
clear();
isFull = true;
return;
}
isFullSelect |= right.isFullSelect;
isFullInsert |= right.isFullInsert;
isFullUpdate |= right.isFullUpdate;
isFullReferences |= right.isFullReferences;
isFullDelete |= right.isFullDelete;
if (isFullSelect) {
selectColumnSet = null;
} else if (right.selectColumnSet != null) {
if (selectColumnSet == null) {
selectColumnSet = new OrderedHashSet();
}
selectColumnSet.addAll(right.selectColumnSet);
}
if (isFullInsert) {
insertColumnSet = null;
} else if (right.insertColumnSet != null) {
if (insertColumnSet == null) {
insertColumnSet = new OrderedHashSet();
}
insertColumnSet.addAll(right.insertColumnSet);
}
if (isFullUpdate) {
updateColumnSet = null;
} else if (right.updateColumnSet != null) {
if (updateColumnSet == null) {
updateColumnSet = new OrderedHashSet();
}
updateColumnSet.addAll(right.updateColumnSet);
}
if (isFullReferences) {
referencesColumnSet = null;
} else if (right.referencesColumnSet != null) {
if (referencesColumnSet == null) {
referencesColumnSet = new OrderedHashSet();
}
referencesColumnSet.addAll(right.referencesColumnSet);
}
if (isFullTrigger) {
triggerColumnSet = null;
} else if (right.triggerColumnSet != null) {
if (triggerColumnSet == null) {
triggerColumnSet = new OrderedHashSet();
}
triggerColumnSet.addAll(right.triggerColumnSet);
}
} | java |
public void remove(SchemaObject object, Right right) {
if (right.isFull) {
clear();
return;
}
if (isFull) {
isFull = false;
isFullSelect = isFullInsert = isFullUpdate = isFullReferences =
isFullDelete = true;
}
if (right.isFullDelete) {
isFullDelete = false;
}
if (!isFullSelect && selectColumnSet == null) {}
else if (right.isFullSelect) {
isFullSelect = false;
selectColumnSet = null;
} else if (right.selectColumnSet != null) {
if (isFullSelect) {
isFullSelect = false;
selectColumnSet = ((Table) object).getColumnNameSet();
}
selectColumnSet.removeAll(right.selectColumnSet);
if (selectColumnSet.isEmpty()) {
selectColumnSet = null;
}
}
if (!isFullInsert && insertColumnSet == null) {}
else if (right.isFullInsert) {
isFullInsert = false;
insertColumnSet = null;
} else if (right.insertColumnSet != null) {
if (isFullInsert) {
isFullInsert = false;
insertColumnSet = ((Table) object).getColumnNameSet();
}
insertColumnSet.removeAll(right.insertColumnSet);
if (insertColumnSet.isEmpty()) {
insertColumnSet = null;
}
}
if (!isFullUpdate && updateColumnSet == null) {}
else if (right.isFullUpdate) {
isFullUpdate = false;
updateColumnSet = null;
} else if (right.updateColumnSet != null) {
if (isFullUpdate) {
isFullUpdate = false;
updateColumnSet = ((Table) object).getColumnNameSet();
}
updateColumnSet.removeAll(right.updateColumnSet);
if (updateColumnSet.isEmpty()) {
updateColumnSet = null;
}
}
if (!isFullReferences && referencesColumnSet == null) {}
else if (right.isFullReferences) {
isFullReferences = false;
referencesColumnSet = null;
} else if (right.referencesColumnSet != null) {
if (isFullReferences) {
isFullReferences = false;
referencesColumnSet = ((Table) object).getColumnNameSet();
}
referencesColumnSet.removeAll(right.referencesColumnSet);
if (referencesColumnSet.isEmpty()) {
referencesColumnSet = null;
}
}
if (!isFullTrigger && triggerColumnSet == null) {}
else if (right.isFullTrigger) {
isFullTrigger = false;
triggerColumnSet = null;
} else if (right.triggerColumnSet != null) {
if (isFullTrigger) {
isFullTrigger = false;
triggerColumnSet = ((Table) object).getColumnNameSet();
}
triggerColumnSet.removeAll(right.triggerColumnSet);
if (triggerColumnSet.isEmpty()) {
triggerColumnSet = null;
}
}
} | java |
static boolean containsAllColumns(OrderedHashSet columnSet, Table table,
boolean[] columnCheckList) {
for (int i = 0; i < columnCheckList.length; i++) {
if (columnCheckList[i]) {
if (columnSet == null) {
return false;
}
if (columnSet.contains(table.getColumn(i).getName())) {
continue;
}
return false;
}
}
return true;
} | java |
String getTableRightsSQL(Table table) {
StringBuffer sb = new StringBuffer();
if (isFull) {
return Tokens.T_ALL;
}
if (isFullSelect) {
sb.append(Tokens.T_SELECT);
sb.append(',');
} else if (selectColumnSet != null) {
sb.append(Tokens.T_SELECT);
getColumnList(table, selectColumnSet, sb);
sb.append(',');
}
if (isFullInsert) {
sb.append(Tokens.T_INSERT);
sb.append(',');
} else if (insertColumnSet != null) {
sb.append(Tokens.T_INSERT);
getColumnList(table, insertColumnSet, sb);
sb.append(',');
}
if (isFullUpdate) {
sb.append(Tokens.T_UPDATE);
sb.append(',');
} else if (updateColumnSet != null) {
sb.append(Tokens.T_UPDATE);
getColumnList(table, updateColumnSet, sb);
sb.append(',');
}
if (isFullDelete) {
sb.append(Tokens.T_DELETE);
sb.append(',');
}
if (isFullReferences) {
sb.append(Tokens.T_REFERENCES);
sb.append(',');
} else if (referencesColumnSet != null) {
sb.append(Tokens.T_REFERENCES);
sb.append(',');
}
if (isFullTrigger) {
sb.append(Tokens.T_TRIGGER);
sb.append(',');
} else if (triggerColumnSet != null) {
sb.append(Tokens.T_TRIGGER);
sb.append(',');
}
return sb.toString().substring(0, sb.length() - 1);
} | java |
public synchronized int next() {
while(nextPort <= MAX_STATIC_PORT) {
int port = nextPort++;
if (MiscUtils.isBindable(port)) {
return port;
}
}
throw new RuntimeException("Exhausted all possible ports");
} | java |
static Range<Long> range(long start, long end) {
return Range.closed(start, end).canonical(DiscreteDomain.longs());
} | java |
private static long start(Range<Long> range) {
if (range.lowerBoundType() == BoundType.OPEN) {
return DiscreteDomain.longs().next(range.lowerEndpoint());
} else {
return range.lowerEndpoint();
}
} | java |
private static long end(Range<Long> range) {
if (range.upperBoundType() == BoundType.OPEN) {
return DiscreteDomain.longs().previous(range.upperEndpoint());
} else {
return range.upperEndpoint();
}
} | java |
public void append(long start, long end) {
assert(start <= end && (m_map.isEmpty() || start > end(m_map.span())));
addRange(start, end);
} | java |
public int truncate(long newTruncationPoint) {
int truncated = 0;
if (m_map.isEmpty()) {
m_map.add(range(newTruncationPoint, newTruncationPoint));
m_hasSentinel = true;
return truncated;
}
if (newTruncationPoint < getFirstSeqNo()) {
return truncated;
}
// Sentinel doesn't count as valid sequence
if (m_hasSentinel) {
truncated -= 1;
}
final Iterator<Range<Long>> iter = m_map.asRanges().iterator();
while (iter.hasNext()) {
final Range<Long> next = iter.next();
if (end(next) < newTruncationPoint) {
truncated += end(next) - start(next) + 1;
iter.remove();
} else if (next.contains(newTruncationPoint)) {
truncated += newTruncationPoint - start(next) + 1;
iter.remove();
m_map.add(range(newTruncationPoint, end(next)));
m_hasSentinel = true;
return truncated;
} else {
break;
}
}
if (!m_map.contains(newTruncationPoint)) {
m_map.add(range(newTruncationPoint, newTruncationPoint));
m_hasSentinel = true;
}
return truncated;
} | java |
public void truncateAfter(long newTruncationPoint) {
if (size() == 0) {
m_map.add(range(newTruncationPoint, newTruncationPoint));
m_hasSentinel = true;
return;
}
if (newTruncationPoint > getLastSeqNo()) {
return;
}
final Iterator<Range<Long>> iter = m_map.asDescendingSetOfRanges().iterator();
while (iter.hasNext()) {
final Range<Long> next = iter.next();
if (start(next) > newTruncationPoint) {
iter.remove();
} else if (next.contains(newTruncationPoint)) {
iter.remove();
m_map.add(range(start(next), newTruncationPoint));
return;
} else {
break;
}
}
if (m_map.isEmpty()) {
m_map.add(range(newTruncationPoint, newTruncationPoint));
m_hasSentinel = true;
}
} | java |
public Pair<Long, Long> getRangeContaining(long seq) {
Range<Long> range = m_map.rangeContaining(seq);
if (range != null) {
return new Pair<Long, Long>(start(range), end(range));
}
return null;
} | java |
public Pair<Long, Long> getFirstGap() {
if (m_map.isEmpty() || size() < 2) {
return null;
}
Iterator<Range<Long>> iter = m_map.asRanges().iterator();
long start = end(iter.next()) + 1;
long end = start(iter.next()) - 1;
return new Pair<Long, Long>(start, end);
} | java |
public int sizeInSequence() {
int sequence = 0;
if (m_map.isEmpty()) {
return sequence;
}
final Iterator<Range<Long>> iter = m_map.asRanges().iterator();
while (iter.hasNext()) {
Range<Long> range = iter.next();
sequence += end(range) - start(range) + 1;
}
if (m_hasSentinel) {
sequence -= 1;
}
return sequence;
} | java |
void sendEvent(CallEvent call) throws NoConnectionsException, IOException, ProcCallException {
if (call.endTS == null) {
assert(call.startTS != null);
// null callback isn't ideal for production code, but errors are tracked
// here through client stats so we'll let it slide
client.callProcedure(new NullCallback(), "BeginCall",
call.agentId, call.phoneNoStr(), call.callId, call.startTS);
}
else {
assert(call.startTS == null);
client.callProcedure(new NullCallback(), "EndCall",
call.agentId, call.phoneNoStr(), call.callId, call.endTS);
}
} | java |
public void write(char[] c, int off, int len) {
ensureRoom(len * 2);
for (int i = off; i < len; i++) {
int v = c[i];
buffer[count++] = (byte) (v >>> 8);
buffer[count++] = (byte) v;
}
} | java |
long executeSQL(boolean isFinal) throws VoltAbortException {
long count = 0;
VoltTable[] results = voltExecuteSQL(isFinal);
for (VoltTable result : results) {
long dmlUpdated = result.asScalarLong();
if (dmlUpdated == 0) {
throw new VoltAbortException("Insert failed for tuple.");
}
if (dmlUpdated > 1) {
throw new VoltAbortException("Insert modified more than one tuple.");
}
++count;
}
return count;
} | java |
protected static boolean _isCloseSurrogateMethod(final Class clazz,
final Method method) {
return ((Connection.class.isAssignableFrom(
clazz) || Statement.class.isAssignableFrom(
clazz)) && "close".equals(method.getName()));
} | java |
protected static Class[] _computeProxiedInterface(Object delegate) {
// NOTE: Order is important for XXXStatement.
if (delegate instanceof Array) {
return arrayInterface;
} else if (delegate instanceof Connection) {
return connectionInterface;
} else if (delegate instanceof CallableStatement) {
return callableStatementInterface;
} else if (delegate instanceof DatabaseMetaData) {
return databaseMetaDataInterface;
} else if (delegate instanceof PreparedStatement) {
return preparedStatementInterface;
} else if (delegate instanceof ResultSet) {
return resultSetInterface;
} else if (delegate instanceof Statement) {
return statementInterface;
} else {
return null;
}
} | java |
protected void closeConnectionSurrogate() throws Throwable {
ConnectionPool connectionPool = this.connectionPool;
if (connectionPool == null) {
// CHECKME: policy?
// pool has "disapeared" or was never provided (why?): should
// "really" close the connection since it will no be reused.
Connection connection = (Connection) this.delegate;
try {
connection.close();
} catch (SQLException ex) {}
} else {
Connection connection = (Connection) this.delegate;
StatementPool statementPool = this.statementPool;
connectionPool.checkIn(connection, statementPool);
}
} | java |
public static String jsonifyClusterTrackers(Pair<Long, Long> lastConsumerUniqueIds,
Map<Integer, Map<Integer, DRSiteDrIdTracker>> allProducerTrackers)
throws JSONException {
JSONStringer stringer = new JSONStringer();
stringer.object();
stringer.keySymbolValuePair("lastConsumerSpUniqueId", lastConsumerUniqueIds.getFirst());
stringer.keySymbolValuePair("lastConsumerMpUniqueId", lastConsumerUniqueIds.getSecond());
stringer.key("trackers").object();
if (allProducerTrackers != null) {
for (Map.Entry<Integer, Map<Integer, DRSiteDrIdTracker>> clusterTrackers : allProducerTrackers.entrySet()) {
stringer.key(Integer.toString(clusterTrackers.getKey())).object();
for (Map.Entry<Integer, DRSiteDrIdTracker> e : clusterTrackers.getValue().entrySet()) {
stringer.key(e.getKey().toString());
stringer.value(e.getValue().toJSON());
}
stringer.endObject();
}
}
stringer.endObject();
stringer.endObject();
return stringer.toString();
} | java |
public static Map<Integer, Map<Integer, DRSiteDrIdTracker>> dejsonifyClusterTrackers(final String jsonData, boolean resetLastReceivedLogIds)
throws JSONException
{
Map<Integer, Map<Integer, DRSiteDrIdTracker>> producerTrackers = new HashMap<>();
JSONObject clusterData = new JSONObject(jsonData);
final JSONObject trackers = clusterData.getJSONObject("trackers");
Iterator<String> clusterIdKeys = trackers.keys();
while (clusterIdKeys.hasNext()) {
final String clusterIdStr = clusterIdKeys.next();
final int clusterId = Integer.parseInt(clusterIdStr);
final JSONObject trackerData = trackers.getJSONObject(clusterIdStr);
Iterator<String> srcPidKeys = trackerData.keys();
while (srcPidKeys.hasNext()) {
final String srcPidStr = srcPidKeys.next();
final int srcPid = Integer.valueOf(srcPidStr);
final JSONObject ids = trackerData.getJSONObject(srcPidStr);
final DRSiteDrIdTracker tracker = new DRSiteDrIdTracker(ids, resetLastReceivedLogIds);
Map<Integer, DRSiteDrIdTracker> clusterTrackers = producerTrackers.computeIfAbsent(clusterId, k -> new HashMap<>());
clusterTrackers.put(srcPid, tracker);
}
}
return producerTrackers;
} | java |
public static void mergeTrackers(Map<Integer, Map<Integer, DRSiteDrIdTracker>> base,
Map<Integer, Map<Integer, DRSiteDrIdTracker>> add)
{
for (Map.Entry<Integer, Map<Integer, DRSiteDrIdTracker>> clusterEntry : add.entrySet()) {
final Map<Integer, DRSiteDrIdTracker> baseClusterEntry = base.get(clusterEntry.getKey());
if (baseClusterEntry == null) {
base.put(clusterEntry.getKey(), clusterEntry.getValue());
} else {
for (Map.Entry<Integer, DRSiteDrIdTracker> partitionEntry : clusterEntry.getValue().entrySet()) {
final DRConsumerDrIdTracker basePartitionTracker = baseClusterEntry.get(partitionEntry.getKey());
if (basePartitionTracker == null) {
baseClusterEntry.put(partitionEntry.getKey(), partitionEntry.getValue());
} else {
basePartitionTracker.mergeTracker(partitionEntry.getValue());
}
}
}
}
} | java |
public JSONWriter array(Iterable<? extends JSONString> iter) throws JSONException {
array();
for (JSONString element : iter) {
value(element);
}
endArray();
return this;
} | java |
public JSONWriter keySymbolValuePair(String aKey, String aValue)
throws JSONException {
assert(aKey != null);
assert(m_mode == 'k');
// The key should not have already been seen in this scope.
assert(m_scopeStack[m_top].add(aKey));
try {
m_writer.write(m_expectingComma ? ",\"" : "\"");
m_writer.write(aKey);
if (aValue == null) {
m_writer.write("\":null");
}
else {
m_writer.write("\":\"");
m_writer.write(JSONObject.quotable(aValue));
m_writer.write('"');
}
}
catch (IOException e) {
throw new JSONException(e);
}
m_expectingComma = true;
return this;
} | java |
public static byte[] gunzipBytes(byte[] compressedBytes) throws IOException
{
ByteArrayOutputStream bos = new ByteArrayOutputStream((int)(compressedBytes.length * 1.5));
InflaterOutputStream dos = new InflaterOutputStream(bos);
dos.write(compressedBytes);
dos.close();
return bos.toByteArray();
} | java |
public Object[] getGroupData(Object[] data) {
if (isSimpleAggregate) {
if (simpleAggregateData == null) {
simpleAggregateData = data;
return null;
}
return simpleAggregateData;
}
RowIterator it = groupIndex.findFirstRow(session, store, data);
if (it.hasNext()) {
Row row = it.getNextRow();
if (isAggregate) {
row.setChanged();
}
return row.getData();
}
return null;
} | java |
public void addConstraint(Constraint c) {
int index = c.getConstraintType() == Constraint.PRIMARY_KEY ? 0
: constraintList
.length;
constraintList =
(Constraint[]) ArrayUtil.toAdjustedArray(constraintList, c, index,
1);
updateConstraintLists();
} | java |
Constraint getUniqueConstraintForColumns(int[] cols) {
for (int i = 0, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
if (c.isUniqueWithColumns(cols)) {
return c;
}
}
return null;
} | java |
Constraint getUniqueConstraintForColumns(int[] mainTableCols,
int[] refTableCols) {
for (int i = 0, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
// A VoltDB extension -- Don't consider non-column expression indexes for this purpose
if (c.hasExprs()) {
continue;
}
// End of VoltDB extension
int type = c.getConstraintType();
if (type != Constraint.UNIQUE && type != Constraint.PRIMARY_KEY) {
continue;
}
int[] constraintCols = c.getMainColumns();
if (constraintCols.length != mainTableCols.length) {
continue;
}
if (ArrayUtil.areEqual(constraintCols, mainTableCols,
mainTableCols.length, true)) {
return c;
}
if (ArrayUtil.areEqualSets(constraintCols, mainTableCols)) {
int[] newRefTableCols = new int[mainTableCols.length];
for (int j = 0; j < mainTableCols.length; j++) {
int pos = ArrayUtil.find(constraintCols, mainTableCols[j]);
newRefTableCols[pos] = refTableCols[j];
}
for (int j = 0; j < mainTableCols.length; j++) {
refTableCols[j] = newRefTableCols[j];
}
return c;
}
}
return null;
} | java |
Constraint getFKConstraintForColumns(Table tableMain, int[] mainCols,
int[] refCols) {
for (int i = 0, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
if (c.isEquivalent(tableMain, mainCols, this, refCols)) {
return c;
}
}
return null;
} | java |
public Constraint getUniqueOrPKConstraintForIndex(Index index) {
for (int i = 0, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
if (c.getMainIndex() == index
&& (c.getConstraintType() == Constraint.UNIQUE
|| c.getConstraintType() == Constraint.PRIMARY_KEY)) {
return c;
}
}
return null;
} | java |
int getNextConstraintIndex(int from, int type) {
for (int i = from, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
if (c.getConstraintType() == type) {
return i;
}
}
return -1;
} | java |
public void addColumn(ColumnSchema column) {
String name = column.getName().name;
if (findColumn(name) >= 0) {
throw Error.error(ErrorCode.X_42504, name);
}
if (column.isIdentity()) {
if (identityColumn != -1) {
throw Error.error(ErrorCode.X_42525, name);
}
identityColumn = getColumnCount();
identitySequence = column.getIdentitySequence();
}
addColumnNoCheck(column);
} | java |
void checkColumnsMatch(int[] col, Table other, int[] othercol) {
for (int i = 0; i < col.length; i++) {
Type type = colTypes[col[i]];
Type otherType = other.colTypes[othercol[i]];
if (type.typeComparisonGroup != otherType.typeComparisonGroup) {
throw Error.error(ErrorCode.X_42562);
}
}
} | java |
OrderedHashSet getDependentConstraints(int colIndex) {
OrderedHashSet set = new OrderedHashSet();
for (int i = 0, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
if (c.hasColumnOnly(colIndex)) {
set.add(c);
}
}
return set;
} | java |
OrderedHashSet getContainingConstraints(int colIndex) {
OrderedHashSet set = new OrderedHashSet();
for (int i = 0, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
if (c.hasColumnPlus(colIndex)) {
set.add(c);
}
}
return set;
} | java |
OrderedHashSet getDependentConstraints(Constraint constraint) {
OrderedHashSet set = new OrderedHashSet();
for (int i = 0, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
if (c.getConstraintType() == Constraint.MAIN) {
if (c.core.uniqueName == constraint.getName()) {
set.add(c);
}
}
}
return set;
} | java |
void checkColumnInFKConstraint(int colIndex, int actionType) {
for (int i = 0, size = constraintList.length; i < size; i++) {
Constraint c = constraintList[i];
if (c.getConstraintType() == Constraint.FOREIGN_KEY
&& c.hasColumn(colIndex)
&& (actionType == c.getUpdateAction()
|| actionType == c.getDeleteAction())) {
HsqlName name = c.getName();
throw Error.error(ErrorCode.X_42533,
name.getSchemaQualifiedStatementName());
}
}
} | java |
public int getColumnIndex(String name) {
int i = findColumn(name);
if (i == -1) {
throw Error.error(ErrorCode.X_42501, name);
}
return i;
} | java |
void setDefaultExpression(int columnIndex, Expression def) {
ColumnSchema column = getColumn(columnIndex);
column.setDefaultExpression(def);
setColumnTypeVars(columnIndex);
} | java |
void resetDefaultsFlag() {
hasDefaultValues = false;
for (int i = 0; i < colDefaults.length; i++) {
hasDefaultValues = hasDefaultValues || colDefaults[i] != null;
}
} | java |
Index getIndexForColumn(int col) {
int i = bestIndexForColumn[col];
return i == -1 ? null
: this.indexList[i];
} | java |
public void createPrimaryKey(HsqlName indexName, int[] columns,
boolean columnsNotNull) {
if (primaryKeyCols != null) {
throw Error.runtimeError(ErrorCode.U_S0500, "Table");
}
if (columns == null) {
columns = ValuePool.emptyIntArray;
} else {
for (int i = 0; i < columns.length; i++) {
getColumn(columns[i]).setPrimaryKey(true);
}
}
primaryKeyCols = columns;
setColumnStructures();
primaryKeyTypes = new Type[primaryKeyCols.length];
ArrayUtil.projectRow(colTypes, primaryKeyCols, primaryKeyTypes);
primaryKeyColsSequence = new int[primaryKeyCols.length];
ArrayUtil.fillSequence(primaryKeyColsSequence);
HsqlName name = indexName;
if (name == null) {
name = database.nameManager.newAutoName("IDX", getSchemaName(),
getName(), SchemaObject.INDEX);
}
createPrimaryIndex(primaryKeyCols, primaryKeyTypes, name);
setBestRowIdentifiers();
} | java |
void addTrigger(TriggerDef td, HsqlName otherName) {
int index = triggerList.length;
if (otherName != null) {
int pos = getTriggerIndex(otherName.name);
if (pos != -1) {
index = pos + 1;
}
}
triggerList = (TriggerDef[]) ArrayUtil.toAdjustedArray(triggerList,
td, index, 1);
TriggerDef[] list = triggerLists[td.vectorIndex];
index = list.length;
if (otherName != null) {
for (int i = 0; i < list.length; i++) {
TriggerDef trigger = list[i];
if (trigger.name.name.equals(otherName.name)) {
index = i + 1;
break;
}
}
}
list = (TriggerDef[]) ArrayUtil.toAdjustedArray(list, td, index, 1);
triggerLists[td.vectorIndex] = list;
} | java |
TriggerDef getTrigger(String name) {
for (int i = triggerList.length - 1; i >= 0; i--) {
if (triggerList[i].name.name.equals(name)) {
return triggerList[i];
}
}
return null;
} | java |
void removeTrigger(String name) {
TriggerDef td = null;
for (int i = 0; i < triggerList.length; i++) {
td = triggerList[i];
if (td.name.name.equals(name)) {
td.terminate();
triggerList =
(TriggerDef[]) ArrayUtil.toAdjustedArray(triggerList,
null, i, -1);
break;
}
}
if (td == null) {
return;
}
int index = td.vectorIndex;
// look in each trigger list of each type of trigger
for (int j = 0; j < triggerLists[index].length; j++) {
td = triggerLists[index][j];
if (td.name.name.equals(name)) {
td.terminate();
triggerLists[index] = (TriggerDef[]) ArrayUtil.toAdjustedArray(
triggerLists[index], null, j, -1);
break;
}
}
} | java |
void releaseTriggers() {
// look in each trigger list of each type of trigger
for (int i = 0; i < TriggerDef.NUM_TRIGS; i++) {
for (int j = 0; j < triggerLists[i].length; j++) {
triggerLists[i][j].terminate();
}
triggerLists[i] = TriggerDef.emptyArray;
}
} | java |
int getIndexIndex(String indexName) {
Index[] indexes = indexList;
for (int i = 0; i < indexes.length; i++) {
if (indexName.equals(indexes[i].getName().name)) {
return i;
}
}
// no such index
return -1;
} | java |
Index getIndex(String indexName) {
Index[] indexes = indexList;
int i = getIndexIndex(indexName);
return i == -1 ? null
: indexes[i];
} | java |
int getConstraintIndex(String constraintName) {
for (int i = 0, size = constraintList.length; i < size; i++) {
if (constraintList[i].getName().name.equals(constraintName)) {
return i;
}
}
return -1;
} | java |
public Constraint getConstraint(String constraintName) {
int i = getConstraintIndex(constraintName);
return (i < 0) ? null
: constraintList[i];
} | java |
Index createIndexForColumns(int[] columns) {
HsqlName indexName = database.nameManager.newAutoName("IDX_T",
getSchemaName(), getName(), SchemaObject.INDEX);
try {
Index index = createAndAddIndexStructure(indexName, columns, null,
null, false, false, false, false);
return index;
} catch (Throwable t) {
return null;
}
} | java |
void enforceRowConstraints(Session session, Object[] data) {
for (int i = 0; i < defaultColumnMap.length; i++) {
Type type = colTypes[i];
data[i] = type.convertToTypeLimits(session, data[i]);
if (type.isDomainType()) {
Constraint[] constraints =
type.userTypeModifier.getConstraints();
for (int j = 0; j < constraints.length; j++) {
constraints[j].checkCheckConstraint(session, this,
data[i]);
}
}
if (data[i] == null) {
if (colNotNull[i]) {
Constraint c = getNotNullConstraintForColumn(i);
if (c == null) {
if (getColumn(i).isPrimaryKey()) {
c = this.getPrimaryConstraint();
}
}
String[] info = new String[] {
c.getName().name, tableName.name
};
throw Error.error(ErrorCode.X_23503, ErrorCode.CONSTRAINT,
info);
}
}
}
} | java |
Index getIndexForColumns(int[] cols) {
int i = bestIndexForColumn[cols[0]];
if (i > -1) {
return indexList[i];
}
switch (tableType) {
case TableBase.SYSTEM_SUBQUERY :
case TableBase.SYSTEM_TABLE :
case TableBase.VIEW_TABLE :
case TableBase.TEMP_TABLE : {
Index index = createIndexForColumns(cols);
return index;
}
}
return null;
} | java |
Index getIndexForColumns(OrderedIntHashSet set) {
int maxMatchCount = 0;
Index selected = null;
if (set.isEmpty()) {
return null;
}
for (int i = 0, count = indexList.length; i < count; i++) {
Index currentindex = getIndex(i);
int[] indexcols = currentindex.getColumns();
int matchCount = set.getOrderedMatchCount(indexcols);
if (matchCount == 0) {
continue;
}
if (matchCount == indexcols.length) {
return currentindex;
}
if (matchCount > maxMatchCount) {
maxMatchCount = matchCount;
selected = currentindex;
}
}
if (selected != null) {
return selected;
}
switch (tableType) {
case TableBase.SYSTEM_SUBQUERY :
case TableBase.SYSTEM_TABLE :
case TableBase.VIEW_TABLE :
case TableBase.TEMP_TABLE : {
selected = createIndexForColumns(set.toArray());
}
}
return selected;
} | java |
public final int[] getIndexRootsArray() {
PersistentStore store =
database.persistentStoreCollection.getStore(this);
int[] roots = new int[getIndexCount()];
for (int i = 0; i < getIndexCount(); i++) {
CachedObject accessor = store.getAccessor(indexList[i]);
roots[i] = accessor == null ? -1
: accessor.getPos();
}
return roots;
} | java |
void setIndexRoots(Session session, String s) {
if (!isCached) {
throw Error.error(ErrorCode.X_42501, tableName.name);
}
ParserDQL p = new ParserDQL(session, new Scanner(s));
int[] roots = new int[getIndexCount()];
p.read();
for (int i = 0; i < getIndexCount(); i++) {
int v = p.readInteger();
roots[i] = v;
}
setIndexRoots(roots);
} | java |
public void dropIndex(Session session, String indexname) {
// find the array index for indexname and remove
int todrop = getIndexIndex(indexname);
indexList = (Index[]) ArrayUtil.toAdjustedArray(indexList, null,
todrop, -1);
for (int i = 0; i < indexList.length; i++) {
indexList[i].setPosition(i);
}
setBestRowIdentifiers();
if (store != null) {
store.resetAccessorKeys(indexList);
}
} | java |
void insertRow(Session session, PersistentStore store, Object[] data) {
setIdentityColumn(session, data);
if (triggerLists[Trigger.INSERT_BEFORE].length != 0) {
fireBeforeTriggers(session, Trigger.INSERT_BEFORE, null, data,
null);
}
if (isView) {
return;
}
checkRowDataInsert(session, data);
insertNoCheck(session, store, data);
} | java |
void insertIntoTable(Session session, Result result) {
PersistentStore store = session.sessionData.getRowStore(this);
RowSetNavigator nav = result.initialiseNavigator();
while (nav.hasNext()) {
Object[] data = nav.getNext();
Object[] newData =
(Object[]) ArrayUtil.resizeArrayIfDifferent(data,
getColumnCount());
insertData(store, newData);
}
} | java |
private Row insertNoCheck(Session session, PersistentStore store,
Object[] data) {
Row row = (Row) store.getNewCachedObject(session, data);
store.indexRow(session, row);
session.addInsertAction(this, row);
return row;
} | java |
public int insertSys(PersistentStore store, Result ins) {
RowSetNavigator nav = ins.getNavigator();
int count = 0;
while (nav.hasNext()) {
insertSys(store, nav.getNext());
count++;
}
return count;
} | java |
void insertResult(PersistentStore store, Result ins) {
RowSetNavigator nav = ins.initialiseNavigator();
while (nav.hasNext()) {
Object[] data = nav.getNext();
Object[] newData =
(Object[]) ArrayUtil.resizeArrayIfDifferent(data,
getColumnCount());
insertData(store, newData);
}
} | java |
public void insertFromScript(PersistentStore store, Object[] data) {
systemUpdateIdentityValue(data);
insertData(store, data);
} | java |
protected void systemUpdateIdentityValue(Object[] data) {
if (identityColumn != -1) {
Number id = (Number) data[identityColumn];
if (id != null) {
identitySequence.systemUpdate(id.longValue());
}
}
} | java |
void deleteNoRefCheck(Session session, Row row) {
Object[] data = row.getData();
fireBeforeTriggers(session, Trigger.DELETE_BEFORE, data, null, null);
if (isView) {
return;
}
deleteNoCheck(session, row);
} | java |
private void deleteNoCheck(Session session, Row row) {
if (row.isDeleted(session)) {
return;
}
session.addDeleteAction(this, row);
} | java |
public void deleteNoCheckFromLog(Session session, Object[] data) {
Row row = null;
PersistentStore store = session.sessionData.getRowStore(this);
if (hasPrimaryKey()) {
RowIterator it = getPrimaryIndex().findFirstRow(session, store,
data, primaryKeyColsSequence);
row = it.getNextRow();
} else if (bestIndex == null) {
RowIterator it = rowIterator(session);
while (true) {
row = it.getNextRow();
if (row == null) {
break;
}
if (IndexAVL.compareRows(
row.getData(), data, defaultColumnMap,
colTypes) == 0) {
break;
}
}
} else {
RowIterator it = bestIndex.findFirstRow(session, store, data);
while (true) {
row = it.getNextRow();
if (row == null) {
break;
}
Object[] rowdata = row.getData();
// reached end of range
if (bestIndex.compareRowNonUnique(
data, bestIndex.getColumns(), rowdata) != 0) {
row = null;
break;
}
if (IndexAVL.compareRows(
rowdata, data, defaultColumnMap, colTypes) == 0) {
break;
}
}
}
if (row == null) {
return;
}
deleteNoCheck(session, row);
} | java |
public void addTTL(int ttlValue, String ttlUnit, String ttlColumn, int batchSize,
int maxFrequency, String streamName) {
dropTTL();
timeToLive = new TimeToLiveVoltDB(ttlValue, ttlUnit, getColumn(findColumn(ttlColumn)),
batchSize, maxFrequency, streamName);
} | java |
static public int getStart(int field) {
Integer iObject = (Integer) starts.get(new Integer(field));
if (iObject == null) {
throw new IllegalArgumentException(
RB.singleton.getString(RB.UNEXPECTED_HEADER_KEY, field));
}
return iObject.intValue();
} | java |
VoltTable executePrecompiledSQL(Statement catStmt, Object[] params, boolean replicated)
throws VoltAbortException {
// Create a SQLStmt instance on the fly
// This is unusual to do, as they are typically required to be final instance variables.
// This only works because the SQL text and plan is identical from the borrowed procedure.
SQLStmt stmt = new SQLStmt(catStmt.getSqltext());
if (replicated) {
stmt.setInCatalog(false);
}
m_runner.initSQLStmt(stmt, catStmt);
voltQueueSQL(stmt, params);
return voltExecuteSQL()[0];
} | java |
protected static void printLogStatic(String className, String msg, Object...args) {
if (args != null) {
msg = String.format(msg, args);
}
String header = String.format("%s [%s] ",
ZonedDateTime.now().format(TIME_FORMAT),
className);
System.out.println(String.format("%s%s",
header, msg.replaceAll("\n", "\n" + header)));
} | java |
StatementSimple compileSetStatement(RangeVariable rangeVars[]) {
read();
OrderedHashSet colNames = new OrderedHashSet();
HsqlArrayList exprList = new HsqlArrayList();
readSetClauseList(rangeVars, colNames, exprList);
if (exprList.size() > 1) {
throw Error.error(ErrorCode.X_42602);
}
Expression expression = (Expression) exprList.get(0);
if (expression.getDegree() != colNames.size()) {
// throw Error.error(ErrorCode.X_42546);
}
int[] indexes = new int[colNames.size()];
ColumnSchema[] variables = new ColumnSchema[colNames.size()];
setVariables(rangeVars, colNames, indexes, variables);
HsqlList unresolved = expression.resolveColumnReferences(rangeVars,
rangeVars.length, null, false);
unresolved = Expression.resolveColumnSet(rangeVars, unresolved, null);
ExpressionColumn.checkColumnsResolved(unresolved);
expression.resolveTypes(session, null);
StatementSimple cs = new StatementSimple(StatementTypes.ASSIGNMENT,
variables, expression, indexes);
return cs;
} | java |
StatementSchema compileCreateProcedureOrFunction() {
int routineType = token.tokenType == Tokens.PROCEDURE
? SchemaObject.PROCEDURE
: SchemaObject.FUNCTION;
HsqlName name;
read();
name = readNewSchemaObjectNameNoCheck(routineType);
Routine routine = new Routine(routineType);
routine.setName(name);
readThis(Tokens.OPENBRACKET);
if (token.tokenType == Tokens.CLOSEBRACKET) {
read();
} else {
while (true) {
ColumnSchema newcolumn = readRoutineParameter(routine);
routine.addParameter(newcolumn);
if (token.tokenType == Tokens.COMMA) {
read();
} else {
readThis(Tokens.CLOSEBRACKET);
break;
}
}
}
if (routineType != SchemaObject.PROCEDURE) {
readThis(Tokens.RETURNS);
if (token.tokenType == Tokens.TABLE) {
read();
TableDerived table =
new TableDerived(database, name, TableBase.FUNCTION_TABLE);
readThis(Tokens.OPENBRACKET);
if (token.tokenType == Tokens.CLOSEBRACKET) {
read();
} else {
while (true) {
ColumnSchema newcolumn = readRoutineParameter(routine);
table.addColumn(newcolumn);
if (token.tokenType == Tokens.COMMA) {
read();
} else {
readThis(Tokens.CLOSEBRACKET);
break;
}
}
}
routine.setReturnTable(table);
} else {
Type type = readTypeDefinition(true);
routine.setReturnType(type);
}
}
readRoutineCharacteristics(routine);
if (token.tokenType == Tokens.EXTERNAL) {
if (routine.getLanguage() != Routine.LANGUAGE_JAVA) {
throw unexpectedToken();
}
read();
readThis(Tokens.NAME);
checkIsValue(Types.SQL_CHAR);
routine.setMethodURL((String) token.tokenValue);
read();
if (token.tokenType == Tokens.PARAMETER) {
read();
readThis(Tokens.STYLE);
readThis(Tokens.JAVA);
}
} else {
startRecording();
Statement statement = readSQLProcedureStatementOrNull(routine,
null);
Token[] tokenList = getRecordedStatement();
String sql = Token.getSQL(tokenList);
statement.setSQL(sql);
routine.setProcedure(statement);
}
Object[] args = new Object[]{ routine };
String sql = getLastPart();
StatementSchema cs = new StatementSchema(sql,
StatementTypes.CREATE_ROUTINE, args, null, null);
return cs;
} | java |
void close(boolean script) {
closeLog();
deleteNewAndOldFiles();
writeScript(script);
closeAllTextCaches(script);
if (cache != null) {
cache.close(true);
}
properties.setProperty(HsqlDatabaseProperties.db_version,
HsqlDatabaseProperties.THIS_VERSION);
properties.setProperty(
HsqlDatabaseProperties.hsqldb_compatible_version,
HsqlDatabaseProperties.FIRST_COMPATIBLE_VERSION);
// set this one last to save the props
properties.setDBModified(HsqlDatabaseProperties.FILES_NEW);
deleteLog();
if (script) {
deleteBackup();
deleteData();
} else {
try {
backupData();
renameNewBackup();
} catch (IOException e) {}
}
renameNewScript();
properties.setProperty(HsqlDatabaseProperties.hsqldb_cache_version,
HsqlDatabaseProperties.THIS_CACHE_VERSION);
properties.setDBModified(HsqlDatabaseProperties.FILES_NOT_MODIFIED);
} | java |
void deleteNewAndOldFiles() {
fa.removeElement(fileName + ".data" + ".old");
fa.removeElement(fileName + ".data" + ".new");
fa.removeElement(fileName + ".backup" + ".new");
fa.removeElement(scriptFileName + ".new");
} | java |
boolean forceDefrag() {
long megas = properties.getIntegerProperty(
HsqlDatabaseProperties.hsqldb_defrag_limit, 200);
long defraglimit = megas * 1024L * 1024;
long lostSize = cache.freeBlocks.getLostBlocksSize();
return lostSize > defraglimit;
} | java |
DataFileCache getCache() {
/*
if (database.isFilesInJar()) {
return null;
}
*/
if (cache == null) {
cache = new DataFileCache(database, fileName);
cache.open(filesReadOnly);
}
return cache;
} | java |
void setScriptType(int type) {
// OOo related code
if (database.isStoredFileAccess()) {
return;
}
// OOo end
boolean needsCheckpoint = scriptFormat != type;
scriptFormat = type;
properties.setProperty(HsqlDatabaseProperties.hsqldb_script_format,
String.valueOf(scriptFormat));
if (needsCheckpoint) {
database.logger.needsCheckpoint = true;
}
} | java |
private void writeScript(boolean full) {
deleteNewScript();
//fredt - to do - flag for chache set index
ScriptWriterBase scw = ScriptWriterBase.newScriptWriter(database,
scriptFileName + ".new", full, true, scriptFormat);
scw.writeAll();
scw.close();
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.