Annotation of pkgsrc/databases/sqlite3/Makefile, revision 1.161

1.161   ! riastrad    1: # $NetBSD: Makefile,v 1.160 2024/11/25 20:20:04 adam Exp $
1.109     kamil       2: 
                      3: .include "Makefile.common"
1.22      tnn         4: 
1.122     adam        5: DISTNAME=      sqlite-autoconf-${SQLITE3_DISTVERSION}
1.95      khorben     6: PKGNAME=       sqlite3-${SQLITE3_VERSION}
1.161   ! riastrad    7: PKGREVISION=   1
1.22      tnn         8: CATEGORIES=    databases
                      9: 
                     10: MAINTAINER=    pkgsrc-users@NetBSD.org
                     11: COMMENT=       SQL Database Engine in a C Library
1.9       heinz      12: 
1.37      agc        13: .include "options.mk"
                     14: 
1.32      adam       15: USE_LIBTOOL=           yes
                     16: USE_TOOLS+=            gmake
1.22      tnn        17: GNU_CONFIGURE=         yes
1.105     adam       18: CONFIGURE_ARGS+=       --disable-static-shell
1.22      tnn        19: 
1.110     kamil      20: PKGCONFIG_OVERRIDE+=   sqlite3.pc.in
                     21: 
1.9       heinz      22: INSTALLATION_DIRS+=    ${PKGMANDIR}/man1
1.1       tv         23: 
1.28      obache     24: .include "../../mk/bsd.prefs.mk"
                     25: 
1.161   ! riastrad   26: # sqlite3 compile options are documented at:
        !            27: #
        !            28: # https://www.sqlite.org/compile.html
        !            29: #
        !            30: # We always enable those options that:
        !            31: #
        !            32: # (a) are not dynamically loadable, but
        !            33: # (b) enable functionality applications are likely to require, and
        !            34: # (c) do not change default settings, and
        !            35: # (d) do not bring unwieldy dependencies, and
        !            36: # (e) do not incur unreasonable burden on users not needing them if
        !            37: #     applicable only to niche use cases.
        !            38: #
        !            39: # We also always enable options that are necessary to build, or are
        !            40: # performance optimizations that do not affect functionality.
        !            41: #
        !            42: # Other options -- those that can be dynamically loaded, those that
        !            43: # change defaults which applications could override anyway, or those
        !            44: # that bring in unwieldy dependencies -- are relegated to options.mk,
        !            45: # e.g. the `icu' option which brings in the unwieldy dependency of
        !            46: # textproc/icu.
        !            47: #
        !            48: # Where both a configure argument option and a C preprocessor macro
        !            49: # option are available, we prefer the configure argument so that it is
        !            50: # checked by the configure script to detect potential bitrot in the
        !            51: # future.
        !            52: 
        !            53: ### Build fixes
1.35      joerg      54: 
1.28      obache     55: # Darwin < 9 (Mac OS X < 10.5 "Leopard") doesn't have gethostuuid(2)
1.81      wiz        56: # and lacks the zone memory allocator
1.28      obache     57: .if !empty(MACHINE_PLATFORM:MDarwin-[0-8].*-*)
1.161   ! riastrad   58: CFLAGS+=               -DSQLITE_ENABLE_LOCKING_STYLE=0
        !            59: CFLAGS+=               -DSQLITE_WITHOUT_ZONEMALLOC
1.28      obache     60: .endif
                     61: 
1.161   ! riastrad   62: ### Performance optimizations
        !            63: 
        !            64: # In the past, Linux had database corruption issues with pread, so only
        !            65: # enable it on safe platforms.  This (undocumented) option enables the
        !            66: # use of pread(2), instead of the sequence of syscalls
        !            67: # lseek(2)-then-read(2), to read from a specific position in a file.
        !            68: CFLAGS.NetBSD+=                -DUSE_PREAD
        !            69: 
        !            70: ### Enabled functionality
1.139     adam       71: 
1.161   ! riastrad   72: # SQLITE_THREADSAFE.  Some applications of sqlite3 in pkgsrc require
        !            73: # thread-safety, so we enable this for everyone.  Applications that
        !            74: # really benefit from omitting mutexes and similar can statically link
        !            75: # a custom build of sqlite3.  We pass the arguments to make sure they
        !            76: # stay enabled in case upstream ever changes the default until we
        !            77: # review the change.
        !            78: CONFIGURE_ARGS+=       --enable-threadsafe
        !            79: 
        !            80: # The column metadata API provides some additional information about
        !            81: # the provenance of columns in query results, and is not dynamically
        !            82: # loadable:
        !            83: #
        !            84: # https://www.sqlite.org/c3ref/column_database_name.html
        !            85: # https://www.sqlite.org/compile.html#enable_column_metadata
1.57      drochner   86: CFLAGS+=               -DSQLITE_ENABLE_COLUMN_METADATA
1.161   ! riastrad   87: 
        !            88: # The DBSTAT virtual table provides information about disk space
        !            89: # utilization, is required by lang/tcl's bin/sqlite3_analyzer, and is
        !            90: # not (as far as I can tell) dynamically loadable:
        !            91: #
        !            92: # https://www.sqlite.org/dbstat.html
        !            93: # https://www.sqlite.org/compile.html#enable_dbstat_vtab
        !            94: CFLAGS+=               -DSQLITE_ENABLE_DBSTAT_VTAB
        !            95: 
        !            96: # Full-text search engines.  There are two full-text search engines,
        !            97: # fts3/4 and fts5.  The options SQLITE_ENABLE_FTS3 and
        !            98: # SQLITE_ENABLE_FTS4 are equivalent; we enable both to make it clear
        !            99: # that that is intended.  fts3 has been available since 3.5.0 in 2007,
        !           100: # the fts4 extension (which is unconditionally bundled with the fts3
        !           101: # build option now) since 3.7.4 in 2010, fts5 since 3.9.0 in 2015, and
        !           102: # all are enabled by default.  We pass the arguments to make sure they
        !           103: # stay enabled in case upstream ever changes the default until we
        !           104: # review the change.
        !           105: #
        !           106: # In principle, fts5 is dynamically loadable, but since upstream
        !           107: # enables it by default anyway we treat that as a moot point.
        !           108: #
        !           109: # https://www.sqlite.org/fts3.html
        !           110: # https://www.sqlite.org/fts5.html
        !           111: # https://www.sqlite.org/compile.html#enable_fts3
        !           112: # https://www.sqlite.org/compile.html#enable_fts4
        !           113: # https://www.sqlite.org/compile.html#enable_fts5
        !           114: CONFIGURE_ARGS+=       --enable-fts3 # -DSQLITE_ENABLE_FTS3
        !           115: CONFIGURE_ARGS+=       --enable-fts4 # -DSQLITE_ENABLE_FTS4
        !           116: CONFIGURE_ARGS+=       --enable-fts5 # -DSQLITE_ENABLE_FTS5
        !           117: 
        !           118: # Nested queries and AND/OR operators for fts3/4.
        !           119: #
        !           120: # https://www.sqlite.org/fts3.html#_set_operations_using_the_enhanced_query_syntax
        !           121: # https://www.sqlite.org/compile.html#enable_fts3_parenthesis
        !           122: CFLAGS+=               -DSQLITE_ENABLE_FTS3_PARENTHESIS
        !           123: 
        !           124: # SQLITE_ENABLE_GEOPOLY, SQLITE_ENABLE_RTREE -- R*Tree and Geopoly
        !           125: # interface for geospatial queries.  Enabled by default since 2018.  We
        !           126: # pass the arguments to make sure they stay enabled in case upstream
        !           127: # ever changes the default until we review the change.
        !           128: #
        !           129: # https://www.sqlite.org/geopoly.html
        !           130: # https://www.sqlite.org/rtree.html
        !           131: # https://www.sqlite.org/compile.html#enable_geopoly
        !           132: # https://www.sqlite.org/compile.html#enable_rtree
        !           133: CONFIGURE_ARGS+=       --enable-rtree
        !           134: 
        !           135: # SQLITE_ENABLE_ICU -- unwieldy dependency, relegated to options.mk.
        !           136: # https://www.sqlite.org/compile.html#enable_icu
        !           137: 
        !           138: # SQLITE_ENABLE_IOTRACE -- experimental and may be discontinued in a
        !           139: # future release.
        !           140: # https://www.sqlite.org/compile.html#enable_iotrace
        !           141: 
        !           142: # Hidden columns.  Allows virtual tables to declare certain columns
        !           143: # HIDDEN, which hides them from PRAGMA table_info, SELECT *, and
        !           144: # implicit INSERT.
        !           145: #
        !           146: # https://www.sqlite.org/vtab.html#hiddencol
        !           147: # https://www.sqlite.org/compile.html#enable_hidden_columns
        !           148: CFLAGS+=               -DSQLITE_ENABLE_HIDDEN_COLUMNS
        !           149: 
        !           150: # SQLITE_ENABLE_JSON1 -- JSON1 support, built-in functions for
        !           151: # manipulating JSON.  Enabled by default since 2022, configure option
        !           152: # removed, compile-time option switched from opt-in to opt-out in
        !           153: # sqlite3>=3.38.0.
        !           154: #
        !           155: # https://www.sqlite.org/json1.html
        !           156: # https://www.sqlite.org/compile.html#enable_json1
        !           157: 
        !           158: # SQLITE_ENABLE_LOCKING_STYLE -- relevant mainly (only?) on Apple
        !           159: # systems, where it is enabled by default anyway.
        !           160: #
        !           161: #      This option enables additional logic in the OS interface layer
        !           162: #      for Mac OS X.  The additional logic attempts to determine the
        !           163: #      type of the underlying filesystem and choose and alternative
        !           164: #      locking strategy that works correctly for that filesystem type.
        !           165: #
        !           166: # Note issue with Darwin < 9 (Mac OS X < 10.5 "Leopard") above.
        !           167: #
        !           168: # https://www.sqlite.org/compile.html#enable_locking_style
        !           169: 
        !           170: # SQLITE_ENABLE_MATH_FUNCTIONS -- SQL math functions: sin/cos/tan,
        !           171: # log/exp, floor/ceil/trunc, &c.  We pass the arguments to make sure
        !           172: # they stay enabled in case upstream ever changes the default until we
        !           173: # review the change.
        !           174: #
        !           175: # https://www.sqlite.org/lang_mathfunc.html
        !           176: # https://www.sqlite.org/compile.html#enable_math_functions
        !           177: CONFIGURE_ARGS+=       --enable-math
        !           178: 
        !           179: # XXX Consider SQLITE_ENABLE_MEMORY_MANAGEMENT.
        !           180: #
        !           181: #      This option adds extra logic to SQLite that allows it to
        !           182: #      release unused memory upon request.  This option must be
        !           183: #      enabled in order for the sqlite3_release_memory() interface to
        !           184: #      work.  If this compile-time option is not used, the
        !           185: #      sqlite3_release_memory() interface is a no-op.
        !           186: #
        !           187: # https://www.sqlite.org/compile.html#enable_memory_management
        !           188: 
        !           189: # SQLITE_ENABLE_MEMSYS3, SQLITE_ENABLE_MEMSYS5 -- alternative memory
        !           190: # allocators, mutually exclusive.  These seem likely to be relevant
        !           191: # only for specialized applications having unusual dynamic memory
        !           192: # allocation requirements, so although this does enable extra
        !           193: # functionality (SQLITE_CONFIG_HEAP,
        !           194: # https://www.sqlite.org/c3ref/c_config_covering_index_scan.html#sqliteconfigheap),
        !           195: # it's not clear which allocator is appropriate to ship by default so
        !           196: # we will not enable either one.
        !           197: #
        !           198: # https://www.sqlite.org/compile.html#enable_memsys3
        !           199: # https://www.sqlite.org/compile.html#enable_memsys5
        !           200: 
        !           201: # XXX Consider -DSQLITE_ENABLE_NORMALIZE.
        !           202: #
        !           203: #      This option includes the sqlite3_normalized_sql() API.
        !           204: #
        !           205: # Unclear what runtime consequences this has.  Unclear what
        !           206: # applications outside https://github.com/bloomberg/comdb2 use this.
        !           207: #
        !           208: # https://www.sqlite.org/compile.html#enable_normalize
        !           209: #
        !           210: # Gentoo enables: https://gitweb.gentoo.org/repo/gentoo.git/tree/dev-db/sqlite/sqlite-3.47.2.ebuild?id=be159693998b95bddf9c118b2425d9f8a2365a67#n211
        !           211: #
        !           212: # Arch Linux does not: https://gitlab.archlinux.org/archlinux/packaging/packages/sqlite/-/blob/bf41f088e6ca945d9374838780d5bacb47653277/PKGBUILD#L42-53
        !           213: # Debian does not: https://sources.debian.org/src/sqlite3/3.46.1-1/debian/rules/#line43
        !           214: # Fedora does not: https://src.fedoraproject.org/rpms/sqlite/blob/182717934c83e9d3ec80f9f818961fd21640c964/f/sqlite.spec#_189
        !           215: # FreeBSD does not: https://cgit.freebsd.org/ports/tree/databases/sqlite3/Makefile?id=8d38e8fbf53dfc94507a466b7269b38a55b167ac#n70
        !           216: # Homebrew does not: https://github.com/Homebrew/homebrew-core/blob/f6ac42c098379841c21ed3a30e150f26187f34b1/Formula/s/sqlite.rb#L35-L58
        !           217: # OpenBSD does not: https://cvsweb.openbsd.org/ports/databases/sqlite3/Makefile?rev=1.132&content-type=text/x-cvsweb-markup
        !           218: #
        !           219: # https://www.sqlite.org/compile.html#enable_normalize
        !           220: 
        !           221: # SQLITE_ENABLE_NULL_TRIM -- minor on-disk space optimization with some
        !           222: # compatibility issues and potentially blob API bugs.  We will let
        !           223: # sleeping dogs lie here.
        !           224: #
        !           225: # https://www.sqlite.org/compile.html#enable_null_trim
        !           226: 
        !           227: # XXX Consider -DSQLITE_ENABLE_OFFSET_SQL_FUNC.
        !           228: #
        !           229: # Unclear what applications need this.  Gentoo and Fedora enable this;
        !           230: # others I checked do not.
        !           231: #
        !           232: #      This option enables support for the sqlite_offset(X) SQL
        !           233: #      function.
        !           234: #
        !           235: #      The sqlite_offset(X) SQL function requires a new interface on
        !           236: #      the B-tree storage engine, a new opcode in the virtual machine
        !           237: #      that runs SQL statements, and a new conditional in a critical
        !           238: #      path of the code generator.  To avoid that overhead in
        !           239: #      applications that do not need the utility of sqlite_offset(X),
        !           240: #      the function is disabled by default.
        !           241: #
        !           242: # https://www.sqlite.org/compile.html#enable_offset_sql_func
        !           243: #
        !           244: #      The sqlite_offset(X) function returns the byte offset in the
        !           245: #      database file for the beginning of the record from which value
        !           246: #      would be read.  If X is not a column in an ordinary table, then
        !           247: #      sqlite_offset(X) returns NULL.  The value returned by
        !           248: #      sqlite_offset(X) might reference either the original table or
        !           249: #      an index, depending on the query.  If the value X would
        !           250: #      normally be extracted from an index, the sqlite_offset(X)
        !           251: #      returns the offset to the corresponding index record.  If the
        !           252: #      value X would be extracted from the original table, then
        !           253: #      sqlite_offset(X) returns the offset to the table record.
        !           254: #
        !           255: # https://www.sqlite.org/lang_corefunc.html#sqlite_offset
        !           256: 
        !           257: # XXX Consider SQLITE_ENABLE_ORDERED_SET_AGGREGATES.
        !           258: #
        !           259: #      This option enables support for the "WITHIN GROUP ORDER BY"
        !           260: #      ordered-set aggregate syntax.  For example:
        !           261: #
        !           262: #          SELECT percentile_cont(0.75) WITHIN GROUP (ORDER BY x) FROM tab;
        !           263: #
        !           264: #      The above is the SQL-standard way to compute the 75-percentile
        !           265: #      value of a distribution.  The usual way to do this in SQLite is
        !           266: #      as follows:
        !           267: #
        !           268: #          SELECT percentile_cont(x,0.75) FROM tab;
        !           269: #
        !           270: #      Though simpler, easier to read, and easier to type, this syntax
        !           271: #      is not compliant with standard SQL.  The simpler, non-standard
        !           272: #      syntax is always available in SQLite.  But the SQL-standard
        !           273: #      compliant syntax is only available if compiled using
        !           274: #      -DSQLITE_ENABLE_ORDERED_SET_AGGREGATES.  The SQL-standard
        !           275: #      compliant syntax is disabled by default because (A) it requires
        !           276: #      about 1,200 bytes of extra code in the compiled SQLite binary
        !           277: #      and (B) because it makes your SQL code more difficult to read,
        !           278: #      write, and understand without adding any value.  Use this
        !           279: #      option only if you need to write cross-platform SQL that uses
        !           280: #      ordered-set aggregate functions such as percentile_cont().
        !           281: #
        !           282: # This might be useful for generic database wrappers that use this
        !           283: # package for a sqlite3 backend.  But nobody else seems to enable this.
        !           284: # So let's hold off until the need arises.
        !           285: #
        !           286: # https://www.sqlite.org/compile.html#enable_ordered_set_aggregates
        !           287: 
        !           288: # SQLITE_ENABLE_PREUPDATE_HOOK, SQLITE_ENABLE_SESSION -- enables the
        !           289: # sqlite3_preupdate_* for pre-update hooks, and the sqlite3session_*
        !           290: # APIs for reifying changesets.
        !           291: #
        !           292: # https://www.sqlite.org/c3ref/preupdate_blobwrite.html
        !           293: # https://www.sqlite.org/sessionintro.html
        !           294: # https://www.sqlite.org/compile.html#enable_preupdate_hook
        !           295: # https://www.sqlite.org/compile.html#enable_session
        !           296: CONFIGURE_ARGS+=       --enable-session
        !           297: 
        !           298: # SQLITE_ENABLE_QPSG -- query planner stability guarantee.  Off by
        !           299: # default.  This option turns it on by default.  Applications can
        !           300: # always use sqlite3_db_config(SQLITE_DBCONFIG_ENABLE_QPSG) to enable
        !           301: # it at run-time, so no need for us to build sqlite3 with it.
        !           302: #
        !           303: # https://www.sqlite.org/queryplanner-ng.html#qpstab
        !           304: # https://www.sqlite.org/compile.html#enable_qpsg
        !           305: 
        !           306: # XXX Consider SQLITE_ENABLE_RBU, Resumable Bulk Updates.
        !           307: #
        !           308: # Gentoo enables this; nobody else I found does.
        !           309: #
        !           310: # https://www.sqlite.org/rbu.html
        !           311: # https://www.sqlite.org/compile.html#enable_rbu
        !           312: 
        !           313: # XXX Consider SQLITE_ENABLE_SNAPSHOT, write-ahead log snapshots.
        !           314: #
        !           315: # Unclear what applications might use this.  Nobody else seems to
        !           316: # enable this.
        !           317: #
        !           318: # https://www.sqlite.org/c3ref/snapshot.html
        !           319: # https://www.sqlite.org/compile.html#enable_snapshot
        !           320: 
        !           321: # SQLITE_ENABLE_SORTER_REFERENCES -- potential optimization whose value
        !           322: # is not clear, off by default.
        !           323: #
        !           324: # https://www.sqlite.org/compile.html#enable_sorter_references
        !           325: 
        !           326: # SQLITE_ENABLE_STMT_SCANSTATUS -- enables sqlite3_stmt_scanstatus and
        !           327: # sqlite3_stmt_scanstatus_v2.
        !           328: #
        !           329: #       Those interfaces are normally omitted from the build because
        !           330: #       they imposes a performance penalty, even on statements that do
        !           331: #       not use the feature.
        !           332: #
        !           333: # https://www.sqlite.org/c3ref/stmt_scanstatus.html
        !           334: # https://www.sqlite.org/compile.html#enable_stmt_scanstatus
        !           335: 
        !           336: # The SQLITE_STMT virtual table provides information about all prepared
        !           337: # statements associated with the database connection.  This is likely
        !           338: # to be useful for performance analysis of applications and does not
        !           339: # appear to have any performance penalty for applications that don't
        !           340: # use it.
        !           341: #
        !           342: # https://www.sqlite.org/stmt.html
        !           343: # https://www.sqlite.org/compile.html#enable_stmtvtab
        !           344: CFLAGS+=               -DSQLITE_ENABLE_STMTVTAB
        !           345: 
        !           346: # SQLITE_RTREE_INT_ONLY
        !           347: #
        !           348: #      This compile-time option is deprecated and untested.
        !           349: #
        !           350: # https://www.sqlite.org/compile.html#rtree_int_only
        !           351: 
        !           352: # SQLITE_ENABLE_SQLLOG
        !           353: #
        !           354: #      This option enables extra code (especially the
        !           355: #      SQLITE_CONFIG_SQLLOG option to sqlite3_config()) that can be
        !           356: #      used to create logs of all SQLite processing performed by an
        !           357: #      application.
        !           358: #
        !           359: # Unclear what applications use this or what it does beyond
        !           360: # sqlite3_trace_v2 (https://www.sqlite.org/c3ref/trace_v2.html).  Can't
        !           361: # find anyone else who enables this.
        !           362: #
        !           363: # https://www.sqlite.org/c3ref/c_config_covering_index_scan.html#sqliteconfigsqllog
        !           364: # https://www.sqlite.org/compile.html#enable_sqllog
        !           365: 
        !           366: # SQLITE_ENABLE_STAT2, SQLITE_ENABLE_STAT3, SQLITE_ENABLE_STAT4 --
        !           367: # statistics tables created by the ANALYZE command.
        !           368: # SQLITE_ENABLE_STAT2 and SQLITE_ENABLE_STAT3 are now ignored.
        !           369: # SQLITE_ENABLE_STAT4 is not enabled by default and it's unclear what
        !           370: # the performance implications are, but it appears likely to expand
        !           371: # disk usage and potentially break the query planner stability
        !           372: # guarantee, so we'll leave it off for now.
        !           373: #
        !           374: # https://www.sqlite.org/fileformat2.html#stat4tab
        !           375: # https://www.sqlite.org/compile.html#enable_stat2
        !           376: # https://www.sqlite.org/compile.html#enable_stat3
        !           377: # https://www.sqlite.org/compile.html#enable_stat4
        !           378: 
        !           379: # SQLITE_ENABLE_TREE_EXPLAIN
        !           380: #
        !           381: #      This compile-time option is no longer used.
        !           382: #
        !           383: # https://www.sqlite.org/compile.html#enable_tree_explain
        !           384: 
        !           385: # XXX Consider SQLITE_ENABLE_UPDATE_DELETE_LIMIT:
        !           386: #
        !           387: #      This option enables an optional ORDER BY and LIMIT clause on
        !           388: #      UPDATE and DELETE statements.
        !           389: #
        !           390: # Unclear what applications might rely on this.  Debian and Gentoo
        !           391: # enable this by default; others do not.
        !           392: #
        !           393: # https://www.sqlite.org/compile.html#enable_update_delete_limit
        !           394: 
        !           395: # XXX Consider SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION -- enables the
        !           396: # `unknown()' function for (and only for) EXPLAIN or EXPLAIN QUERY
        !           397: # PLAN, as a substitute for any functions sqlite3 does not recognize.
        !           398: #
        !           399: #      When used in the command-line shell, the
        !           400: #      SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION feature allows SQL text that
        !           401: #      contains application-defined functions to be pasted into the
        !           402: #      shell for analysis and debugging without having to create and
        !           403: #      load an extension that implements the application-defined
        !           404: #      functions.
        !           405: #
        !           406: # However, this might be useful _only_ for the command-line shell;
        !           407: # unclear what applications might rely on failure vs unknown().
        !           408: #
        !           409: # https://www.sqlite.org/compile.html#enable_unknown_sql_function
        !           410: 
        !           411: # SQLITE_ENABLE_UNLOCK_NOTIFY -- enables sqlite3_unlock_notify(),
        !           412: # needed for various sqlite3 API calls to sleep rather than fail with
        !           413: # SQLITE_LOCKED when another thread is using another connection to the
        !           414: # same database, so they can be woken by the other thread when it is
        !           415: # done.  Needed by, e.g., Firefox.
        !           416: #
        !           417: # https://www.sqlite.org/unlock_notify.html
        !           418: # https://www.sqlite.org/compile.html#enable_unlock_notify
        !           419: CFLAGS+=               -DSQLITE_ENABLE_UNLOCK_NOTIFY
        !           420: 
        !           421: # SQLITE_INTROSPECTION_PRAGMAS
        !           422: #
        !           423: #      This option is obsolete.
        !           424: #
        !           425: # https://www.sqlite.org/compile.html#introspection_pragmas
        !           426: 
        !           427: # XXX Consider SQLITE_SOUNDEX:
        !           428: #
        !           429: #      This option enables the soundex() SQL function.
        !           430: #
        !           431: # Debian and Gentoo enable this by default; others do not.
        !           432: #
        !           433: # https://www.sqlite.org/lang_corefunc.html#soundex
        !           434: # https://www.sqlite.org/compile.html#soundex
        !           435: 
        !           436: # XXX Consider SQLITE_STRICT_SUBTYPE=1:
        !           437: #
        !           438: #      This option causes application-defined SQL functions to raise
        !           439: #      an SQL error if they invoke the sqlite3_result_subtype()
        !           440: #      interface but where not registered with the
        !           441: #      SQLITE_RESULT_SUBTYPE property.  This recommended option helps
        !           442: #      to identify problems in the implementation of
        !           443: #      application-defined SQL functions early in the development
        !           444: #      cycle.
        !           445: #
        !           446: # Debian and FreeBSD enable this; others do not.
        !           447: #
        !           448: # https://www.sqlite.org/compile.html#strict_subtype
        !           449: 
        !           450: # XXX Consider SQLITE_USE_ALLOCA:
        !           451: #
        !           452: #      If this option is enabled, then the alloca() memory allocator
        !           453: #      will be used in a few situations where it is appropriate.  This
        !           454: #      results in a slightly smaller and faster binary.  The
        !           455: #      SQLITE_USE_ALLOCA compile-time only works, of course, on
        !           456: #      systems that support alloca().
        !           457: #
        !           458: # Nobody else seems to enable this.
        !           459: #
        !           460: # https://www.sqlite.org/compile.html#use_alloca
        !           461: 
        !           462: # XXX Consider SQLITE_USE_FCNTL_TRACE:
        !           463: #
        !           464: #      This option causes SQLite to issue extra SQLITE_FCNTL_TRACE
        !           465: #      file controls to provide supplementary information to the VFS.
        !           466: #      The "vfslog.c" extension makes use of this to provide enhanced
        !           467: #      logs of VFS activity.
        !           468: #
        !           469: # Nobody else seems to enable this.  Unclear what applications this
        !           470: # benefits.
        !           471: #
        !           472: # https://www.sqlite.org/compile.html#use_fcntl_trace
        !           473: 
        !           474: # SQLITE_USE_SEH
        !           475: #
        !           476: #      Client code should not use this define, as it is used
        !           477: #      internally by the library.
        !           478: #
        !           479: # https://www.sqlite.org/compile.html#use_seh
        !           480: 
        !           481: # XXX Consider SQLITE_HAVE_ZLIB:
        !           482: #
        !           483: #      This option has no effect on the SQLite core.  It is only used
        !           484: #      by extensions.  This is option is necessary for the compression
        !           485: #      and decompression functions that are part of SQL Archive
        !           486: #      support in the command-line shell.
        !           487: #
        !           488: # https://www.sqlite.org/compile.html#have_zlib
        !           489: 
        !           490: # XXX Consider YYTRACKMAXSTACKDEPTH:
        !           491: #
        !           492: #      This option causes the LALR(1) parser stack depth to be tracked
        !           493: #      and reported using the
        !           494: #      sqlite3_status(SQLITE_STATUS_PARSER_STACK,...)  interface.
        !           495: #      SQLite's LALR(1) parser has a fixed stack depth (determined at
        !           496: #      compile-time using the YYSTACKDEPTH options).  This option can
        !           497: #      be used to help determine if an application is getting close to
        !           498: #      exceeding the maximum LALR(1) stack depth.
        !           499: 
        !           500: # SQLITE_OMIT_LOAD_EXTENSION (old: !SQLITE_ENABLE_LOAD_EXTENSION)
        !           501: #
        !           502: # Make sure this is consistently enabled on all platforms -- this way
        !           503: # the build fails early if something goes wrong with getting at dlopen.
        !           504: # (XXX If we have platforms without dlopen, we may want to disable this
        !           505: # on those platforms.)
        !           506: #
        !           507: # https://www.sqlite.org/compile.html#omit_load_extension
        !           508: CONFIGURE_ARGS+=       --enable-load-extension
1.29      tnn       509: 
1.16      epg       510: # Uses dlopen and friends but doesn't use -ldl on Linux.
                    511: # See http://www.sqlite.org/cvstrac/tktview?tn=3555
                    512: LIBS+=                 ${BUILDLINK_LDADD.dl}
                    513: 
1.161   ! riastrad  514: # Solaris needs -lrt for nanosleep, PR pkg/58714
1.156     nia       515: LIBS.SunOS+=           -lrt
                    516: 
1.80      ryoon     517: .if ${OS_VARIANT} == "SCOOSR5"
                    518: LDFLAGS.SCO_SV+=       -lpthread
                    519: .endif
                    520: 
1.127     sevan     521: .include "../../mk/pthread.buildlink3.mk"
1.67      ryoon     522: .include "../../mk/readline.buildlink3.mk"
1.16      epg       523: .include "../../mk/dlopen.buildlink3.mk"
1.1       tv        524: .include "../../mk/bsd.pkg.mk"

CVSweb <webmaster@jp.NetBSD.org>