I don't see how that could be possible. "*" means all attributes that an entity has so there can't be a default.

i.e., there is no info on what an entity does not have.

Let me try to explain how I would do it in two queries.

(let [attributes (d/q '[:find [?a ...]
                          :where
                          [?e ?a _]]
                        db)
        pattern (mapv (fn [attribute]
                        `(~attribute :default :no-value))
                      attributes)]
    (d/q `[:find (pull $ ~pattern ?e)
           :in $
           :where
           [?e _ _]]
         db))

Something along those lines.

Definitely not something built in. I'd advise against that. What is your use case?

If you want ?string-val-0 to unify the outer clause you’ll need to include it in the rules-vars vector: (or-join [?e ?string-val-0] …)

At least I suspect that’s what’s wrong.

(t/instant #inst "2020-09-26T23:08:27.619-00:00") => #time/instant "2020-09-26T23:08:27.619Z"

(t/format "yyyy/MM/dd" (t/instant #inst "2020-09-26T23:08:27.619-00:00")) => Execution error (UnsupportedTemporalTypeException) at java.time.Instant/getLong (Instant.java:603). Unsupported field: YearOfEra

the clojure.java-time docs for t/instant say this function "Creates an Instant" https://cljdoc.org/d/clojure.java-time/clojure.java-time/0.3.2/api/java-time.temporal#instant

(t/instant? (.toInstant #inst "2020-09-26T23:08:27.619-00:00")) => true (t/instant? (t/instant #inst "2020-09-26T23:08:27.619-00:00")) => true

This works: (t/format ".dd" (t/zoned-date-time 2015 9 28)) => "2015.09.28" but I can't find a way to convert a datomic db.type/instant to a zoned-date-time.

There must be a more straightforward way to format datomic datetime values.

@U078GPYL8

user=> (t/format "dd/MM/yyyy" (t/zoned-date-time #inst "2020-09-26T23:08:27.619-00:00" (t/zone-id "UTC")))
"26/09/2020"
user=> 

(or whatever TZ you need there)

Although if you're dealing with #inst which I believe are just regular java.util.Date objects, this should work (without clojure.java-time at all):

user=> (let [f (java.text.SimpleDateFormat. "dd/MM/yyyy")]
         (.format f #inst "2020-09-26T23:08:27.619-00:00"))
"26/09/2020"
user=> 

Yup, Datomic docs say it's just a java.util.Date:

:db.type/instant	instant in time	java.util.Date	#inst "2017-09-16T11:43:32.450-00:00"

@U04V70XH6 Thanks very much! I've confirmed that both approaches work as expected with an #inst returned from datomic.

I've learned a lot here, both by dipping my toes into the clojure.java-time and tick libraries, and getting a more practical sense of how java interop works through your example.

@U078GPYL8 I meant something like this (sorry, was on a phone earlier):

(let [d #inst"2020-10-03T12:18:02.445-00:00"
      f (-> (java.time.format.DateTimeFormatter/ofPattern "dd/MM/yyyy")
            (.withZone (java.time.ZoneId/systemDefault)))]
  (.format f (.toInstant d)))

I avoid java.text.SimpleDateFormat because it’s the “old” way and it’s not thread-safe

I think what sean posted is nearly the equivalent, except he coerces to a zoned date time instead of specifying the zone in the formatter

but I’m not familiar with clojure.java-time, I just use java.time directly

@U09R86PA4 I see what you originally meant evaluating

(let [d #inst"2020-10-03T12:18:02.445-00:00"
                       f (-> (java.time.format.DateTimeFormatter/ofPattern "dd/MM/yyyy")
                             (.withZone (java.time.ZoneId/systemDefault)))]
                   (.format f d))

The same error is produced without the date being wrapped in a .toInstant call.

In what type of use case would the fact that SimpleDateFormat is not thread safe produce an unexpected result, particularly in the context of a web application?

Def the format object and then use it in functions running in my tools threads

*multiple

There are a few strata of Java date systems

The oldest is Java.util.date objects. The newest is Java.time.*, which represents instants as Java.time.Instant objects instead.

There are some in between that aren’t worth learning anymore

Yup, going via Java Time is definitely the safest route and the best set of APIs to learn. At work, over the past decade we've gone from java.util.Date to date-clj (date arithmetic for that old Date type), to clj-time (wrapping Joda Time), to Java Time (with clojure.java-time in some parts of the code and plain interop in a lot of places). Converting java.util.Date to java.time.Instant and doing everything in Java Time is a bit painful/verbose, but you can write utility functions for stuff you need frequently to hide that interop/verbosity.