def convert_date(self, d):
if d is not None:
if isinstance(d, basestring):
return Timestamp(ReleaseSqlPublisher.ISO_DATE_TIME_FORMAT.parseDateTime(d).getMillis())
else:
return Timestamp(DateTime(d).getMillis())
return None
def test_datetime(self):
self.assertEquals(datetime.datetime(2008, 1, 1),
Py.newDatetime(Timestamp(108, 0, 1, 0, 0, 0, 0)))
self.assertEquals(datetime.datetime(2008, 5, 29, 16, 50, 0),
Py.newDatetime(Timestamp(108, 4, 29, 16, 50, 0, 0)))
self.assertEquals(datetime.datetime(2008, 5, 29, 16, 50, 1, 1),
Py.newDatetime(Timestamp(108, 4, 29, 16, 50, 1, 1000)))
def test_mat_view_date_rounding(self):
tableCursor = table3Cursor(self.context)
mViewCursor = mView4Cursor(self.context)
tableCursor.deleteAll()
self.assertEquals(0, mViewCursor.count())
datetime1 = LocalDateTime.of(2000, Month.AUGUST, 5, 10, 5, 32)
date1 = datetime1.truncatedTo(ChronoUnit.DAYS)
tableCursor.numb = 5
tableCursor.date = Timestamp.valueOf(datetime1)
tableCursor.insert()
tableCursor.clear()
datetime2 = LocalDateTime.of(2000, Month.AUGUST, 5, 22, 5, 32)
tableCursor.numb = 2
tableCursor.date = Timestamp.valueOf(datetime2)
tableCursor.insert()
tableCursor.clear()
datetime3 = LocalDateTime.of(2000, Month.AUGUST, 6, 10, 5, 32)
date2 = datetime3.truncatedTo(ChronoUnit.DAYS)
tableCursor.numb = 5
tableCursor.date = Timestamp.valueOf(datetime3)
tableCursor.insert()
tableCursor.clear()
self.assertEquals(2, mViewCursor.count())
mViewCursor.get(Timestamp.valueOf(date1))
self.assertEquals(7, mViewCursor.s)
mViewCursor.get(Timestamp.valueOf(date2))
self.assertEquals(5, mViewCursor.s)
def _to_timestamp(d):
if isinstance(d, datetime.datetime):
calendar = GregorianCalendar()
calendar.set(d.year, d.month - 1, d.day, d.hour, d.minute, d.second)
ts = Timestamp(calendar.getTimeInMillis())
ts.setNanos(d.microsecond * 1000)
return ts
else:
return d
def findTimestamp(self, dateTup, timeTup):
str_date = dateTup + " " + timeTup + " GMT"
formatter = SimpleDateFormat("dd MMM yyyy HH:mm:ss z")
p_date = formatter.parse(str_date)
parsed_year = p_date.getYear()
if parsed_year > 3000:
print "parsed year is too large: " + str(parsed_year)
return 0
else:
sc_tmstmp = Timestamp(p_date.getTime())
return sc_tmstmp.getTime() / 1000
def findTimestamp (self, dateTup, timeTup):
str_date = dateTup + " " + timeTup + " GMT"
formatter = SimpleDateFormat("dd MMM yyyy HH:mm:ss z")
p_date = formatter.parse(str_date)
parsed_year = p_date.getYear()
if parsed_year > 3000:
print "parsed year is too large: " + str(parsed_year)
return 0
else:
sc_tmstmp = Timestamp (p_date.getTime())
return sc_tmstmp.getTime() / 1000
def test_getdate_in_view(self):
tableCursor = getDateForViewCursor(self.context)
tableCursor.deleteAll()
viewCursor = viewWithGetDateCursor(self.context)
self.assertEquals(0, viewCursor.count())
tableCursor.date = Timestamp.valueOf(LocalDateTime.now().minusDays(1))
tableCursor.insert()
self.assertEquals(0, viewCursor.count())
tableCursor.clear()
tableCursor.date = Timestamp.valueOf(LocalDateTime.now().plusDays(1))
tableCursor.insert()
self.assertEquals(1, viewCursor.count())
def updateToken(self, tokenObject):
self.resetErrors()
index = "resumptionTokens-UPDATE"
sql = """
UPDATE resumptionTokens
SET start = ?, expiry = ?
WHERE token = ?
"""
fields = [
tokenObject.getStart(),
Timestamp(tokenObject.getExpiry()),
tokenObject.getToken()
]
try:
self.db.execute(self.dbName, index, sql, fields)
#self.log.debug("=== updateToken()")
#self.log.debug("=== TOKEN: '{}'", tokenObject.getToken())
#self.log.debug("=== METADATAPREFIX: '{}'", tokenObject.getMetadataPrefix())
#self.log.debug("=== EXPIRY: '{}'", tokenObject.getExpiry())
#self.log.debug("=== TOTALFOUND: '{}'", tokenObject.getTotalFound())
#self.log.debug("=== START: '{}'", tokenObject.getStart())
return True
except Exception, e:
# Something is wrong
self.log.error("ERROR: ", e)
self.error = True
self.errorMsg = self.parseError(e)
return False
def storeToken(self, tokenObject):
self.resetErrors()
index = "resumptionTokens-STORE"
table = "resumptionTokens"
fields = {
"token": tokenObject.getToken(),
"metadataPrefix": tokenObject.getMetadataPrefix(),
"expiry": Timestamp(tokenObject.getExpiry()),
"nextToken": tokenObject.getNextToken(),
"resultJson": ""
}
FileUtils.writeStringToFile(
File(
FascinatorHome.getPath("oaipmh-results") + "/" +
tokenObject.getToken()), tokenObject.getResultJson())
#self.log.debug("=== storeToken()")
#self.log.debug("=== TOKEN: '{}'", tokenObject.getToken())
#self.log.debug("=== METADATAPREFIX: '{}'", tokenObject.getMetadataPrefix())
#self.log.debug("=== EXPIRY: '{}'", tokenObject.getExpiry())
#self.log.debug("=== TOTALFOUND: '{}'", tokenObject.getTotalFound())
#self.log.debug("=== START: '{}'", tokenObject.getStart())
try:
self.db.insert(self.dbName, index, table, fields)
except Exception, e:
msg = self.parseError(e)
if msg == "Duplicate record!":
# Expected failure
self.log.error("Duplicate record already exists in table!")
else:
# Something is wrong
self.log.error("ERROR: ", e)
self.error = True
self.errorMsg = msg
def insert_file_data_to_db_batch():
'''
FUNC FOR DATA INSERTING INTO DATABASE
'''
ins_log("Adding data to DB...", 'Using JDBC from File')
global conn, unarchived_file, lnNum, totalRecords, batch_size
conn.setSchema(s_schema)
truncate_table()
conn.setAutoCommit(False)
#jdbc_insert_sql = 'insert into dim_invalid_passports (pass_serial, pass_no, valid_to_dttm) values (?,?,?)';
jdbc_insert_sql = 'insert into dim_invalid_passports (pass_serial, pass_no, sys_actual_flg, sys_deleted_flg, valid_from_dttm, valid_to_dttm, sys_mod_by) values (?, ?, ?, ?, ?, ?, ? )'
#print(jdbc_insert_sql);
sql_statement = conn.prepareStatement(jdbc_insert_sql)
reader = CSVReader(FileReader(unarchived_file))
#/* Read CSV file in OpenCSV */
nextLine = reader.readNext()
while reader.readNext() != None:
lnNum += 1
sql_statement.setString(1, replace_str(reader.readNext()[0]))
sql_statement.setString(2, replace_str(reader.readNext()[1]))
sql_statement.setInt(3, 1)
sql_statement.setInt(4, 0)
sql_statement.setTimestamp(5, Timestamp(System.currentTimeMillis()))
sql_statement.setString(6, "01.01.2400")
sql_statement.setString(7, "ODI_USER")
sql_statement.addBatch()
if lnNum % batch_size == 0 or reader.readNext() == None:
sql_statement.executeBatch()
#print(sql_statement.executeBatch());
conn.commit()
sql_statement.close()
ins_log('File inserted, ' + str(lnNum) + " rows added;",
str(jdbc_insert_sql) + ' batch_size = ' + str(batch_size))
conn.close()
def _testInFilterWithAdditionalLookup(self, a, b, g):
aTableCursor = aFilterCursor(self.context)
bTableCursor = bFilterCursor(self.context)
gTableCursor = gFilterCursor(self.context)
aTableCursor.deleteAll()
bTableCursor.deleteAll()
gTableCursor.deleteAll()
timestamp = Timestamp.valueOf(LocalDateTime.now())
self._fillTablesForTestInFilterWithRangeOnOtherCursor(aTableCursor, bTableCursor, timestamp)
gTableCursor.createDate = timestamp
gTableCursor.num1 = 5
gTableCursor.num2 = -30
gTableCursor.insert()
gTableCursor.clear()
gTableCursor.createDate = timestamp
gTableCursor.num1 = 6
gTableCursor.num2 = -40
gTableCursor.insert()
gTableCursor.clear()
gTableCursor.createDate = timestamp
gTableCursor.num1 = 1
gTableCursor.num2 = -41
gTableCursor.insert()
gTableCursor.clear()
gTableCursor.createDate = timestamp
gTableCursor.num1 = 1
gTableCursor.num2 = -42
gTableCursor.insert()
gTableCursor.clear()
lookup = a.setIn(b).add("date", "created").add("number1", "numb1")
additionalLookup = lookup.and(g).add("date", "createDate").add("number1", "num1")
self.assertEquals(3, a.count())
b.setRange('numb2', -40)
self.assertEquals(2, a.count())
a.first()
self.assertEquals(5, a.number1)
self.assertEquals(-10, a.number2)
a.navigate('>')
self.assertEquals(6, a.number1)
self.assertEquals(-20, a.number2)
g.setRange('num2', -30)
self.assertEquals(1, a.count())
a.first()
self.assertEquals(5, a.number1)
self.assertEquals(-10, a.number2)
def _testInFilterWithRangeInOtherCursorAfterSetIn(self, a, b):
aTableCursor = aFilterCursor(self.context)
bTableCursor = bFilterCursor(self.context)
aTableCursor.deleteAll()
bTableCursor.deleteAll()
timestamp = Timestamp.valueOf(LocalDateTime.now())
self._fillTablesForTestInFilterWithRangeOnOtherCursor(aTableCursor, bTableCursor, timestamp)
lookup = a.setIn(b).add("date", "created").add("number1", "numb1")
self.assertEquals(3, a.count())
b.setRange('numb2', -40)
self.assertEquals(2, a.count())
a.first()
self.assertEquals(5, a.number1)
self.assertEquals(-10, a.number2)
a.navigate('>')
self.assertEquals(6, a.number1)
self.assertEquals(-20, a.number2)
def _testInFilterForIndices(self, a, b):
aTableCursor = aFilterCursor(self.context)
bTableCursor = bFilterCursor(self.context)
aTableCursor.deleteAll()
bTableCursor.deleteAll()
timestamp = Timestamp.valueOf(LocalDateTime.now())
aTableCursor.date = timestamp
aTableCursor.number1 = 5
aTableCursor.number2 = -10
aTableCursor.insert()
aTableCursor.clear()
aTableCursor.date = timestamp
aTableCursor.number1 = 1
aTableCursor.number2 = -20
aTableCursor.insert()
aTableCursor.clear()
aTableCursor.date = Timestamp.valueOf(LocalDateTime.now().plusDays(1))
aTableCursor.number2 = -30
aTableCursor.insert()
aTableCursor.clear()
bTableCursor.created = timestamp
bTableCursor.numb1 = 2
bTableCursor.numb2 = -40
bTableCursor.insert()
bTableCursor.clear()
bTableCursor.created = timestamp
bTableCursor.numb1 = 5
bTableCursor.numb2 = -50
bTableCursor.insert()
bTableCursor.clear()
lookup = a.setIn(b).add("date", "created")
self.assertEquals(2, a.count())
lookup = a.setIn(b).add("date", "created").add("number1", "numb1")
self.assertEquals(1, a.count())
a.setIn(b).add("date", "created").add("number1", "numb1").add("number2", "numb2")
self.assertEquals(0, a.count())
def _testInFilterWithRangeInMainCursor(self, a, b):
aTableCursor = aFilterCursor(self.context)
bTableCursor = bFilterCursor(self.context)
aTableCursor.deleteAll()
bTableCursor.deleteAll()
timestamp = Timestamp.valueOf(LocalDateTime.now())
aTableCursor.date = timestamp
aTableCursor.number1 = 5
aTableCursor.number2 = -10
aTableCursor.insert()
aTableCursor.clear()
aTableCursor.date = timestamp
aTableCursor.number1 = 1
aTableCursor.number2 = -20
aTableCursor.insert()
aTableCursor.clear()
aTableCursor.date = Timestamp.valueOf(LocalDateTime.now().plusDays(1))
aTableCursor.number2 = -30
aTableCursor.insert()
aTableCursor.clear()
bTableCursor.created = timestamp
bTableCursor.numb1 = 2
bTableCursor.numb2 = -40
bTableCursor.insert()
bTableCursor.clear()
bTableCursor.created = timestamp
bTableCursor.numb1 = 5
bTableCursor.numb2 = -50
bTableCursor.insert()
bTableCursor.clear()
a.setRange('number1', 5)
lookup = a.setIn(b).add("date", "created")
self.assertEquals(1, a.count())
a.first()
def testFormat():
dataManager = DALLocator.getDataManager()
ws = dataManager.getDatabaseWorkspace("ARENA2_DB")
server = ws.getServerExplorer()
accidentesParameters = server.get("ARENA2_ACCIDENTES")
dataManager = DALLocator.getDataManager()
store = dataManager.openStore(accidentesParameters.getProviderName(),
accidentesParameters)
ft = store.getDefaultFeatureType()
ehora = ft.getAttributeDescriptor("HORA_ACCIDENTE")
ekm = ft.getAttributeDescriptor("KM")
from java.sql import Timestamp
from java.util import Date
ts = Timestamp(Date().getTime())
print ehora.format(ts)
print ekm.format(10.282999895)
from java.lang import String
print String.format("%.3f", 10.39283)
print String.format("%tR", Timestamp(Date().getTime()))
def test_getXRec(self):
cursor = tXRecCursor(self.context)
cursor.deleteAll()
id = 1
num = 10
cost = 10.2
title = 'product'
isActive = True
created = Timestamp.valueOf(
LocalDateTime.of(2018, Month.of(1), 11, 19, 15))
cursor.num = num
cursor.cost = cost
cursor.title = title
cursor.isActive = isActive
cursor.created = created
xRec = cursor.getXRec()
self._assertXRecCursorFields(xRec, None, None, None, None, None, None)
cursor.insert()
self._assertXRecCursorFields(xRec, None, None, None, None, None, None)
cursor.clear()
xRec = cursor.getXRec()
self._assertXRecCursorFields(xRec, None, None, None, None, None, None)
cursor.get(1)
self._assertXRecCursorFields(xRec, id, num, cost, title, isActive,
created)
cursor.num = num + 1
cursor.cost = cost + 1
cursor.title = title + 'asd'
cursor.isActive = False
cursor.created = Timestamp.valueOf(
LocalDateTime.of(2017, Month.of(1), 11, 19, 15))
self._assertXRecCursorFields(xRec, id, num, cost, title, isActive,
created)
def jTimestamp(da):
# print da,type(da)
if type(da) == java.sql.Timestamp: return da
y = da.year - 1900
m = da.month - 1
d = da.day
ho = da.hour
mi = da.minute
se = da.second
ti = Timestamp(y, m, d, ho, mi, se, 0)
# print "tttt",ti
return ti
def test_count_with_getdate_condition(self):
tableCursor = countGetDateCondCursor(self.context)
tableCursor.deleteAll()
viewCursor = viewCountGetDateCondCursor(self.context)
viewCursor.first()
self.assertEquals(0, viewCursor.c)
tableCursor.insert()
tableCursor.clear()
tableCursor.date = Timestamp.valueOf(
LocalDateTime.now().minusSeconds(2))
tableCursor.insert()
viewCursor.first()
self.assertEquals(0, viewCursor.c)
tableCursor.clear()
tableCursor.date = Timestamp.valueOf(LocalDateTime.now().plusDays(1))
tableCursor.insert()
viewCursor.first()
self.assertEquals(1, viewCursor.c)
def _fillTablesForTestInFilterWithRangeOnOtherCursor(self, a, b, timestamp):
a.date = timestamp
a.number1 = 5
a.number2 = -10
a.insert()
a.clear()
a.date = timestamp
a.number1 = 6
a.number2 = -20
a.insert()
a.clear()
a.date = timestamp
a.number1 = 1
a.number2 = -20
a.insert()
a.clear()
a.date = Timestamp.valueOf(LocalDateTime.now().plusDays(1))
a.number2 = -30
a.insert()
a.clear()
b.created = timestamp
b.numb1 = 6
b.numb2 = -40
b.insert()
b.clear()
b.created = timestamp
b.numb1 = 5
b.numb2 = -40
b.insert()
b.clear()
b.created = timestamp
b.numb1 = 1
b.numb2 = -41
b.insert()
b.clear()
from com.atlassian.jira.component import ComponentAccessor
from java.sql import Timestamp
import time
customFieldManager = ComponentAccessor.getCustomFieldManager()
userManager = ComponentAccessor.getUserManager()
cfLastCaller = customFieldManager.getCustomFieldObject(11850)
cfLastTime = customFieldManager.getCustomFieldObject(10135)
caller = transientVars.get('context').getCaller()
callTime = Timestamp(int(round(time.time() * 1000)))
issue.setCustomFieldValue(cfLastCaller, userManager.getUserByKey(caller))
issue.setCustomFieldValue(cfLastTime, callTime)
def findTimestamp(self, timeField):
print "converting time: " + timeField
formatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss z")
p_date = formatter.parse(timeField + " HST")
sc_tmstmp = Timestamp(p_date.getTime())
return sc_tmstmp.getTime() / 1000
def findTimestamp (self, timeField):
print "converting time: " + timeField
formatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss z")
p_date = formatter.parse(timeField + " HST")
sc_tmstmp = Timestamp (p_date.getTime())
return sc_tmstmp.getTime() / 1000
