SQLAPI.dscript

# ---------------------------------------------------------------------------- #
#                                                                              |
#                                                                              |
#                         D e n i z e n   S Q L A P I                          |
#                                                                              |
#                 An API for scripters to easily implement SQL                 |
#                                                                              |
#                               *REQUIRES MYSQL*                               |
#                                                                              |
#                                                                              |
#   Author: |Anthony|                                                          |
#   Version: 0.1.3                                                             |
#   dScript Version: 0.9.6-dev-199                                             |
#                                                                              |
#   Dependencies:                                                              |
#   - SQLManager:             http://mcmonkey.org/denizen/repo/entry/19        |
#   - ConfigFileGenerator:    http://mcmonkey.org/denizen/repo/entry/7         |
#                                                                              |
# ---------------------------------------------------------------------------- #
#
#
# ABOUT:
#
#     SQLAPI is a library or API for Denizen scripters to easily implement SQL
#   in their scripts. It is intended to supplement the denizen flag system for
#   those who require data to be shared across a network of servers since
#   Denizen currently has no cross server flag capability.
#
#     The SQL backend functions are almost /completely/ handled by SQLManager.
#   Automatically goes into offline caching mode if the sql database goes
#   offline!
#
#
#------------------------------------------------
#
# USAGE:
#
# -- Setup
#
#   1. Create an empty SQL database on your server. You can name it anything you
#      like. The default name is SQLAPI.
#      Consult your operating system manual or other online documentation for
#      instructions how to install and setup an sql server if needed. That is
#      beyond the scope of this documentation.
#
#   2. Install SQLManager.dscript following the instructions provided. SQLAPI
#      Will not load if SQLManager is not installed!
#
#   3. Install sqlapi.dscript to you Denizen scripts folder and type:
#      /denizen reload scripts
#
#   4. From console or in game (with sqlapi.admin permission) type:
#      /sqlapi --restart
#      This will extract the config file to /Denizen/SQLAPI/config.yml
#      SQLAPI will begin the connection attempt process, but will fail until
#      you edit the config.yml file with valid connection information.
#
#   5. Edit the config.yml file with valid connection information for your SQL
#      database created in step 1. If you have edit config.yml before the
#      connection attempt cycle expires, SQLAPI will proceed with setup, if not
#      you will need to repeat step 4.
#
#   6. SQLAPI is now installed! Rejoice!
#
#
# -- Permissions
#
#    Admin permission: sqlapi.admin
#
#
#------------------------------------------------
#
# API Guidelines and Explanation
#
# -- Notes
#
#  - SQLAPI utilizes the events system for setting/editing/deleting sql flags.
#    - Learn more about the events command: http://mcmonkey.org/denizen/cmds/event
#
#    - The events command in Denizen lacks the ability to handle lists directly
#      in the context section. You MUST use the .escaped tag when supplying a
#      list value!
#
# -- Setting/Editing/Deleting Flags
#
#    Working with SQL flags is easy! You must specify the type, flagName,
#  and flagValue context fields when you do. The duration field is optional. The
#  owner field is not used for the server type flags.
#
#    Full Example:
#    - event 'sqlflag set' 'context:owner|<playerObject>|flagName|myFlag|flagValue|potato|duration|5s'
#
#
# -- Context Fields
#
#  ~ Type
#
#    There are four (4) flag types available through SQLAPI.
#    - Type Values
#      - server - Global flags with no owner
#      - player - Player specific flags
#      - npc    - NPC specific flags
#      - entity - Entity specific flags (not fully implemented)
#
#    Example:
#    'context:type|player'
#
#
#  ~ Owner
#
#    The owner field is required for player, npc, and entity flag types, but is
#   NOT required for server type flags. The owner field must contain a valid
#   entity object for that particular flag type. A player type flag must have
#   a <player> object in the owner field. An NPC flag must have an <npc> object
#   in the owner field. An entity flag must have an <entity> object in the owner
#   field.
#
#    Example:
#    'context:owner|<player>'
#
#
#  ~ FlagName
#
#    The flagName field is where you declare the name of your flag. Flag names
#   MUST be unique. Setting a flag value on an existing flag will overwrite it.
#   Players, NPCs, and entities all have their own flag associations, which
#   means that player A and player B can both have a flag named 'potato' with no
#   conflicts.
#
#    Flag names are limited to roughly 21,844 UTF-8 characters. You should have
#   plenty of room for exotic flag names.
#
#    Example:
#    'context:flagName|potato'
#
#
#  ~ FlagValue
#
#    The flagValue field is where you store the value of your flag. It can hold
#   any string, integer, decimal, boolean, or list value you like. It has a
#   theoretical limit of 5,592,404 UTF-8 characters.
#
#    When working with a list flagValue, you must escape the whole list. This is
#   required to overcome a limitation with the events command. Your data will be
#   stored and returned to you correctly. You may also choose to use your own
#   delimiter. You will be responsible for recreating your lists when you
#   retrieve the value.
#    Example:
#    - define list 'li@a|b|c'
#    - event 'sqlflag set' 'context:type|server|flagName|myFlag|flagValue|<def[list].escaped>'
#
#
#  ~ Duration
#
#    The duration field is an optional field for all flags. Setting a duration
#   on a flag will make the flag available for specific amount of time. The
#   value for the duration field can be provided in any of the following
#   formats: T=ticks, M=minutes, S=seconds, H=hours, D=days, W = Weeks.
#   Not using a unit will imply seconds.
#    Example:
#    - event 'sqlflag set' 'context:duration|10s'
#
#------------------------------------------------
#
#               C h a n g e l o g
#
# - v0.1.3  -  4/29/15
#   - Implement the event system
#     - Scripts are encouraged to use the event system and NOT the command system
#   - Break up the sqlflag command into its constituent parts.
#     - Results in a flagString parser
#   - Add fancy linewrapp and formatted message system
#     - Run almost all messages through the message system
#
# - v0.1.2  -  4/28/15
#   - List index manipulations
#     - Insert: Inserts additional values starting at the specified index
#     - Set: Inserts additional values replacing the specified index
#   - Added <proc[SQLAPI_Expiration].context[owner|flag]>
#     - Returns a Duration of the time remaining on the flag
#     - Returns d@0t if the flag does not expire
#     - Does not return if the flag is expired or is not set
#     - Owner can be server, or any valid <player>, <npc>, or <entity> object
#   - Added <proc[SQLAPI_ListFlags].context[owner]||null>
#     - List all unexpired flags for <owner>
#     - Owner can be server, or any valid <player>, <npc>, or <entity> object
#   - Added <proc[SQLAPI_GetFlagged].context[type|flag]||null>
#     - List all owners of the specified type that have the specified flag set.
#     - Valid types are player, npc, and entity
#   - Added <proc[SQLAPI_GetCurrentFlagged].context[type|flag]||null>
#     - List all owners of the specified type that have the specified flag set.
#     - Valid types are player, npc, and entity
#     - Will only return owner objects for those (players) that are online or
#       (npcs or entities) that are spawned.
#
#
# - v0.1.1  -  4/27/15
#   - Correctly distinguish between existent and expired flags when editing lists
#   - Math functions. Can now increment, decrement, multiply, and divide flags
#
# - v0.1.1  -  4/26/15
#   - Make <proc[SQLAPI_GetFlag].context[owner|flag]||null> handle lists natively
#   - Set list function works, may be expanded/revised at a later date
#   - Added Include and Remove list functions
#
# - v0.1.1  -  4/25/15
#   - Don't store escaped values in the db
#
# - v0.1.1  -  4/21/15
#   - Added <proc[SQLAPI_GetFlag].context[owner|flag]||null>
#     - Returns the flag value
#     - Does not return if the flag doesn't exist or is expired.
#
# - v0.1.1  -  4/20/15
#   - Added <proc[SQLAPI_ParseOwner].context[owner]||null>
#     - Specify an owner object and it returns the type.
#     - Return values are player, entity, npc, server, and thisPlayer.
#     - Does not return on invalid input. Notify console instead
#     - 'thisPlayer' is a literal string and should be handled in the calling
#       script. It's intended for the sqlflag command so the literal string
#       'player' can be used to denote the person issuing the command.
#   - Simplified the context required for GetFlagRecord, FlagExists, IsExpired,
#     and HasFlag procedure scripts. Now only require the owner and flag context
#     Eg.: <proc[SQLAPI_HasFlag].context[owner|flag]>
#
# - v0.1.1  -  4/20/15
#   - sqlflag command
#     - Allows setting/editing/deleting flags in game with a command
#     - Currently only the set flag code is written. Don't try to do any list
#       flags or removing flags yet!
#   - Added <proc[SQLAPI_GetFlagRecord].context[tablename|owner|flag]||null>
#     - Returns a raw flag record li@flagName|flagValue|expiriation
#     - Returns "SQLAPI OFFLINE" if the db is offline
#     - Really only meant for internal usage. There will be more user friendly
#       options available in the future.
#   - Added <proc[SQLAPI_FlagExists].context[tablename|owner|flag]>
#     - Boolean tag to check if a flag exists
#     - Does not return if the db is offline
#     - Really only meant for internal usage.
#   - Added <proc[SQLAPI_IsExpired].context[tablename|owner|flag]>
#     - Boolean tag to check if a flag exists
#     - Does not return if the flag does not exist OR the db is offline.
#     - Really only meant for internal usage.
#   - Added <proc[SQLAPI_HasFlag].context[tablename|owner|flag]>
#     - Boolean tag to check if a object has a flag.
#     - Returns true if the flag exists and is not expired.
#     - Returns false if the flag does not exist or is expired.
#     - Does not return if the db is offline.
#
# - v0.1  -  4/13/15
#   - Initial commit
#
#
#------------------------------------------------
#
#          TODO - Future Feature Fluff
#
#
#______________________________________________________________________________#

SQLAPI:
  type: world
  speed: 0
  debug: false
  action_map:
    set_list: '&pipe'
    include: '-&gt'
    remove: '&lt-'
    increment: '++|+'
    decrement: '--|-'
    multiply: '**|*'
    divide: '&fs&fs|&fs'
    clear: '&exc'

  events:
    on server start:
    - run locally start delay:1t

    on sqlflag set:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define flagValue '<c.flagValue.unescaped.sql_escaped||true>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally set_flag

    on sqlflag set_index:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define index '<c.index.unescaped.sql_escaped.as_int||1>'
    - define flagValue '<c.flagValue.unescaped.sql_escaped||true>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally set_index_flag

    on sqlflag clear:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - inject locally clear_flag

    on sqlflag include:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define flagValue '<c.flagValue.unescaped.sql_escaped>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally include_flag

    on sqlflag insert_index:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define index '<c.index.unescaped.sql_escaped.as_int||1>'
    - define flagValue '<c.flagValue.unescaped.sql_escaped||true>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally insert_index_flag

    on sqlflag remove:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define flagValue '<c.flagValue.unescaped.sql_escaped>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally remove_flag

    on sqlflag increment:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define flagValue '<c.flagValue.unescaped.sql_escaped.as_decimal||1>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally increment_flag

    on sqlflag decrement:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define flagValue '<c.flagValue.unescaped.sql_escaped.as_decimal||1>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally decrement_flag

    on sqlflag multiply:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define flagValue '<c.flagValue.unescaped.sql_escaped.as_decimal||1>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally multiply_flag

    on sqlflag divide:
    - define owner '<c.owner>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
    - if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagName '<c.flagName.sql_escaped||null>'
    - if %flagName% == null || <def[flagName].length> == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flagName!'
      - queue clear
      }
    - define flagValue '<c.flagValue.unescaped.sql_escaped.as_decimal||1>'
    - define expiration '<c.expiration.sql_escaped.as_duration.in_milliseconds.add_int[<server.current_time_milliseconds>]||0>'
    - inject locally divide_flag

    on sqlapi command:
    - if !<player.permission[sqlapi.admin]||false> && !<player.is_op> && !<c.server> {
      - queue clear
      }
    - determine passively FULFILLED
    - define arg1 '<c.args.get[1].escaped||null>'
    - if <def[arg1].is[==].to[--restart]> {
      - run s@SQLAPI_Msg delay:1t 'def:<&d>Restarting System!'
      - define isRelaod ''
      - inject locally start
      }

    on sqlflag command:
    - define time '<server.current_time_millis>'
    - if !<player.permission[sqlapi.admin]||false> && !<player.is_op> && !<c.server> {
      - queue clear
      }
    - determine passively FULFILLED
    - if <c.args.size> < 2 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>/sqlflag <&lt>owner<&gt> flagName(<&lb>#<&rb>)(<&co>action)(<&co>value) (duration<&co>duration)'
      - queue clear
      }

    - define owner '<parse:<c.args.get[1]||null>>'
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if %type% == null {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify valid flag holder!'
      - queue clear
      }
      else if %type% == thisPlayer {
      - if <c.server> {
        - announce to_console "<&b>SQLAPI<&co><&c> Must specify valid player object from console!"
        - queue clear
        }
      - define type 'player'
      - define owner '<player>'
      }
      else if %type% != server {
      - define owner '<def[owner].as_%type%>'
      }
    - define flagString '<c.args.get[2]>'
    - inject locally parse_FlagString

    - define duration '<c.args.get[3]||null>'
    - if <def[duration].starts_with[d<&co>]> || <def[duration].starts_with[duration<&co>]> {
      - define expiration '<def[duration].split[<&co>].get[2].as_duration||null>'
      - if %expiration% == null {
        - announce to_console '<&b>SQLAPI<&co><&c> <def[expiration].split[<&co>].get[2]||null> is not a valid duration!'
        - define expiration '0'
        }
        else {
        - define expiration '<def[expiration].in_milliseconds.add_int[<server.current_time_milliseconds>]>'
        }
      }
      else {
      - define expiration '0'
      }
#    - announce "Narrate values"
#    - narrate "<&2>==="
#    - narrate "size %size%"
#    - narrate "owner %owner% %type% <def[owner].uuid>"
#    - narrate "flag %flagName%"
#    - narrate "action %action%"
#    - narrate "flagvalue %flagvalue%"
#    - narrate "expiration %expiration%"
    - inject locally %action%_flag
    - inject locally msg_%action%
    - narrate "Time taken<&co> <server.current_time_millis.sub_int[%time%]>ms"
    - queue clear

  parseAction:
    - define actions '<script.list_keys[action_map]>'
    - foreach %actions% {
      - define map '<script.yaml_key[action_map.%value%].as_list||li@>'
      - if <def[map].contains_any[%action%]||false> {
        - define action '<def[value].to_lowercase>'
        - foreach stop
        }
      }
    - if %actions% !contains %action% {
      - define action 'set'
      }


  parse_FlagString:
    - define preparse '<def[flagString].escaped.split[&co]||null>'
    - define size '<def[preparse].size>'
    - define flagName '<def[preparse].get[1].unescaped.to_lowercase.sql_escaped||null>'
    - if %flagName% contains <&lb> {
      - define index '<def[flagName].after[<&lb>].replace[<&rb>]>'
      - define flagName '<def[flagName].before[<&lb>]>'
      - if <def[index].length> == 0 || %index% !matches number {
        - define index:!
        }
      }
    - if %size% > 2 {
      - define size 'extra'
      }
    - inject locally parse_flagString_%size%

  parse_flagString_1:
    - define flagValue 'true'
    - define action 'set'

  parse_flagString_2:
    - define action '<def[preparse].get[2]||null>'
    - inject locally parseAction
    - if <li@set|clear|increment|decrement|multiply|divide> contains %action% {
      - if %action% == set {
        - define flagValue '<def[preparse].get[2].unescaped.sql_escaped>'
        - if <def[index].exists> {
          - define action 'set_index'
          }
        }
        else if %action% != clear {
        - narrate "set value to 1"
        - define flagValue '1'
        }
      }
      else {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Must specify a flag value for %action% flag action!'
      - queue clear
      }

  parse_flagString_Extra:
    - define flagValue '<def[flagString].after[<def[preparse].get[2].unescaped><&co>].sql_escaped||null>'
    - define action '<def[preparse].get[2]||null>'
    - inject locally parseAction
    - if <def[index].exists> {
      - if li@set|set_list contains %action% {
        - define action 'set_index'
        }
        else if %action% == include {
        - define action 'insert_index'
        }
      }
    - if %action% == set {
      - define flagValue '<def[flagString].after[<def[preparse].get[1].unescaped><&co>].sql_escaped||null>'
      }
      else if <li@increment|decrement|multiply|divide> contains %action% {
      - if %flagValue% !matches decimal {
        - run s@SQLAPI_Msg delay:1t 'def:<&c>%flagValue% is not a valid number!'
        - queue clear
        }
      }


  start:
    - ^define yamlName 'SQLAPI'
    - ^define scriptName '<script.name>'
    - ^inject locally reloadYaml instantly
    - ^inject locally loadData instantly
    - ^if %useSql% {
      - announce "<&b>SQLAPI<&co><&c> Must be configured to use MySQL!" to_console
      - inject locally unload
      - queue stop
      }
    # Verify SQLManager is installed and ready
    - ^if !<server.list_scripts.parse[name].contains[SQLManager]> {
      - announce "<&b>SQLAPI<&co><&c> SQLManager not installed!" to_console
      - inject locally unload
      - queue stop
      }
    - ^repeat %retry% {
      - if !<yaml.list.contains[SQLManager_Offline]> {
        - announce "<&b>SQLAPI<&co><&c> Could not connect to SQLManager!" to_console
        - if %loop_index% == %retry% {
          - inject locally unload
          - queue stop
          }
        - announce "<&b>SQLAPI<&co><&c> Will attempt again in %retryDelay%..." to_console
        - wait %retryDelay%
        }
      }
    # This checks the status as set by SQLManager to not duplicate restart
    # processes. This is the only time this script needs to set the status.
    # The SQLManager will handle every other situation.
    - ^define status '<yaml[SQLManager_Offline].read[Offline_Cache.databases.%db%.status]||null>'
    - ^if <def[status].is[==].to[connecting]> {
      - announce "<&b>SQLManager<&co><&c> Already attempting to reconnect to %db% database!" to_console
      - queue stop
      }
      else {
      - yaml set 'id:SQLManager_Offline' 'Offline_Cache.databases.%db%.status:connecting'
      - yaml 'savefile:SQLManager/cache.yml' 'id:SQLManager_Offline'
      }
    - ^if <def[isReload].exists||false> {
      - run s@SQLManager p:restart delay:1t def:%yamlName%|%scriptName%|%db%
      - queue clear
      }
    - ^inject s@SQLManager
    - ^announce "<&b>SQLAPI<&co><&a> System loaded!" to_console
    - queue stop

  reloadYaml:
  # Reloads the yaml files and generates default files if they don't exist.
    - announce "<&b>SQLAPI<&co><&3> Loading system config files..." to_console
    - if !<server.has_file[SQLAPI/config.yml]> {
      - if <player> != null {
        - flag <player> ConfigFileGeneratorNotify:true
        - run s@ConfigFileGeneratorHelper def:SQLAPI|Configurations|false|false|false instantly
        - flag <player> ConfigFileGeneratorNotify:!
        }
        else {
        - run s@ConfigFileGeneratorHelper def:SQLAPI|Configurations instantly
        }
      }
    - if <yaml.list.contains[SQLAPI_config]> yaml unload 'id:SQLAPI_config'
    - yaml 'load:SQLAPI/config.yml' 'id:SQLAPI_config'
    - inject s@SQLAPI_SQLTables
    - announce "<&b>SQLAPI<&co><&a> System config files Loaded!" to_console

  loadData:
    - ^define yamlName 'SQLAPI'
    - ^define scriptName '<script.name>'
    - ^define useSql '<yaml[SQLAPI_config].read[config.MySQL.useSql]||false>'
    - ^define retry '<yaml[SQLAPI_config].read[config.MySQL.retry]||3>'
    - ^define retryDelay '<yaml[SQLAPI_config].read[config.MySQL.retryDelay]||10s>'
    - ^define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - ^define PlayerSQLFLagsTable '<yaml[SQLAPI_config].read[config.MySQL.tables.PlayerSQLFLags]||dsqlapi_playersqlflags>'
    - ^define NPCSQLFLagsTable '<yaml[SQLAPI_config].read[config.MySQL.tables.NPCSQLFLags]||dsqlapi_npcsqlflags>'
    - ^define EntitySQLFLagsTable '<yaml[SQLAPI_config].read[config.MySQL.tables.EntitySQLFLags]||dsqlapi_entitysqlflags>'
    - ^define ServerSQLFLagsTable '<yaml[SQLAPI_config].read[config.MySQL.tables.ServerSQLFLags]||dsqlapi_serversqlflags>'

  unload:
    - ^if <yaml.list.contains[SQLAPI_config]> {
      - announce "<&b>SQLAPI<&co><&3> Unloading config.yml file..." to_console
      - yaml unload 'id:SQLAPI_config'
      }
    - ^if <yaml.list.contains[SQLAPI_SQLTables]> {
      - announce "<&b>SQLAPI<&co><&3> Unloading SQLAPI_SQLTables file..." to_console
      - yaml unload 'id:SQLAPI_SQLTables'
      }
    - ^announce "<&b>SQLAPI<&co><&c> System disabled..." to_console


  clear_flag:
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define flagExists '<proc[SQLAPI_FlagExists].context[%owner%|%flagName%]||offline>'
    - if %flagExists% == offline {
      - announce to_console "<&b>SQLAPI<&co><&c> System Offline! Can not remove %flagName% for %owner%!"
      - queue clear
      }
    - if !%flagExists% {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>%owner% does not set %flagName%!'
      - queue clear
      }
    - if %type% == server {
      - define statement "DELETE FROM %tableName% WHERE flag='%flagName%';"
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - define statement "DELETE FROM %tableName% WHERE flag='%flagName%' AND uuid='%uuid%';"
      }
#    - sql id:%db% "update:<def[statement]>" save:id
    - inject s@SQLManager_Offline p:managedUpdateStatement

  set_flag:
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define flagExists '<proc[SQLAPI_FlagExists].context[%owner%|%flagName%]>'
    - if %flagExists% == offline {
      - announce to_console "<&b>SQLAPI<&co><&c> System Offline! Can not set %flagName% for %owner% to %flagValue% in %tableName%!"
      - queue clear
      }

    - if %type% == server {
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  set_index_flag:
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - announce to_console "<&b>SQLAPI<&co><&c> System Offline! Can not set index %index% %flagName% for %owner% to %flagValue% in %tableName%!"
      - queue clear
      }
    - if %record% != null {
      - define flagExists 'true'
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define isExpired 'false'
        }
        else {
        - define isExpired 'true'
        }
      }
      else {
      - define flagExists 'false'
      - define isExpired 'true'
      }

    - if %flagExists% && !%isExpired% {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if <def[flagVal].starts_with[|]> {
        - define flagVal '<def[flagVal].as_list>'
        - define flagValue '<&pipe><def[flagVal].get[2].to[<def[flagVal].size>].set[%flagValue%].at[%index%].replace[li@]>'
        }
        else {
        - define flagValue '<&pipe>%flagValue%'
        }
      }
      else {
      - define flagValue '<&pipe>%flagValue%'
      }

    - if %type% == server {
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  set_list_flag:
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>System Offline! Can not set %flagName% for %owner% to %flagValue% in %tableName%!'
      - queue clear
      }
    - if %record% != null {
      - define flagExists 'true'
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define isExpired 'false'
        }
        else {
        - define isExpired 'true'
        }
      }
      else {
      - define flagExists 'false'
      - define isExpired 'true'
      }

    - if %flagExists% && !%isExpired% {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if <def[flagVal].starts_with[|]> {
        - define flagVal '<def[flagVal].as_list>'
        - define flagValue '<&pipe><def[flagVal].get[2].to[<def[flagVal].size>].replace[li@]><&pipe>%flagValue%'
        }
        else {
        - define flagValue '<&pipe>%flagValue%'
        }
      }
      else {
      - define flagValue '<&pipe>%flagValue%'
      }

    - if %type% == server {
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  include_flag:
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>System Offline! Can not include %flagValue% in %flagName% for %owner% in %tableName%!'
      - queue clear
      }
    - if %record% != null {
      - define flagExists 'true'
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define isExpired 'false'
        }
        else {
        - define isExpired 'true'
        }
      }
      else {
      - define flagExists 'false'
      - define isExpired 'true'
      }

    - if %flagExists% && !%isExpired% {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if <def[flagVal].starts_with[|]> {
        - define flagVal '<def[flagVal].as_list>'
        - define flagValue '<&pipe><def[flagVal].get[2].to[<def[flagVal].size>].replace[li@]><&pipe>%flagValue%'
        }
        else {
        - define flagValue '<&pipe>%flagValue%'
        }
      }
      else {
      - define flagValue '<&pipe>%flagValue%'
      }

    - if %type% == server {
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  insert_index_flag:
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>System Offline! Can not insert %flagValue% at index %index% for %flagName% for %owner% in %tableName%!'
      - queue clear
      }
    - if %record% != null {
      - define flagExists 'true'
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define isExpired 'false'
        }
        else {
        - define isExpired 'true'
        }
      }
      else {
      - define flagExists 'false'
      - define isExpired 'true'
      }

    - if %flagExists% && !%isExpired% {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if <def[flagVal].starts_with[|]> {
        - define flagVal '<def[flagVal].as_list>'
        - define flagValue '<&pipe><def[flagVal].get[2].to[<def[flagVal].size>].insert[%flagValue%].at[%index%].replace[li@]>'
        }
        else {
        - define flagValue '<&pipe>%flagValue%'
        }
      }
      else {
      - define flagValue '<&pipe>%flagValue%'
      }

    - if %type% == server {
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  remove_flag:
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>System Offline! Can not remove %flagValue% from %flagName% for %owner% in %tableName%!'
      - queue clear
      }
    - if %record% != null {
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define flagExists 'true'
        }
        else {
        - define flagExists 'false'
        }
      }
      else {
      - define flagExists 'false'
      }

    - if !%flagExists% {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>%owner% does not set %flagName%!'
      - queue clear
      }
    - define flagVal '<def[record].get[2].unescaped.as_list||null>'
    - if <def[flagVal].as_list.contains_any[%flagValue%]> {
      - define flagValue '<&pipe><def[flagVal].get[2].to[<def[flagVal].size>].exclude[%flagValue%].replace[li@]>'
      }
      else {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>%flagName% does not contain any %flagValue% for %owner%!'
      - queue clear
      }

    - if <def[flagValue].is[==].to[<&pipe>]> {
      - define delete 'true'
      }
      else {
      - define delete 'false'
      }

    - if %type% == server {
      - if %delete% {
        - define statement "DELETE FROM %tableName% WHERE flag='%flagName%';"
        }
        else {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %delete% {
        - define statement "DELETE FROM %tableName% WHERE flag='%flagName%' AND uuid='%uuid%';"
        }
        else {
        - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  increment_flag:
    - if %flagValue% !matches decimal {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>%flagValue% is not a valid number! Not incrementing %flagName% for %owner%!'
      - queue clear
      }
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>System Offline! Can not increment %flagName% for %owner% by %flagValue% in %tableName%!'
      - queue clear
      }
    - if %record% != null {
      - define flagExists 'true'
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define isExpired 'false'
        }
        else {
        - define isExpired 'true'
        }
      }
      else {
      - define flagExists 'false'
      - define isExpired 'true'
      }

    - if %flagExists% {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if %flagVal% !matches decimal {
        - run s@SQLAPI_Msg delay:1t 'def:<&c>Not incrementing %flagName% for %owner%! Current value %flagVal% is not numeric!'
        - queue clear
        }
      }

    - if %type% == server {
      - if %flagExists% {
        - if %isExpired% {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
          }
          else {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = value + '%flagValue%' WHERE flag='%flagName%';"
          }
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - if %isExpired% {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
          }
          else {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = value + '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
          }
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  decrement_flag:
    - if %flagValue% !matches decimal {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>%flagValue% is not a valid number! Not decrementing %flagName% for %owner%!'
      - queue clear
      }
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>System Offline! Can not decrement %flagName% for %owner% by %flagValue% in %tableName%!'
      - queue clear
      }
    - if %record% != null {
      - define flagExists 'true'
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define isExpired 'false'
        }
        else {
        - define isExpired 'true'
        }
      }
      else {
      - define flagExists 'false'
      - define isExpired 'true'
      }

    - if %flagExists% {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if %flagVal% !matches decimal {
        - run s@SQLAPI_Msg delay:1t 'def:<&c>Not decrementing %flagName% for %owner%! Current value %flagVal% is not numeric!'
        - queue clear
        }
      }

    - if %type% == server {
      - if %flagExists% {
        - if %isExpired% {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
          }
          else {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = value - '%flagValue%' WHERE flag='%flagName%';"
          }
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - if %isExpired% {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
          }
          else {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = value - '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
          }
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  multiply_flag:
    - if %flagValue% !matches decimal {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>%flagValue% is not a valid number! Not multiplying %flagName% for %owner%!'
      - queue clear
      }
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>System Offline! Can not multiply %flagName% for %owner% by %flagValue% in %tableName%!'
      - queue clear
      }
    - if %record% != null {
      - define flagExists 'true'
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define isExpired 'false'
        }
        else {
        - define isExpired 'true'
        }
      }
      else {
      - define flagExists 'false'
      - define isExpired 'true'
      }

    - if %flagExists% {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if %flagVal% !matches decimal {
        - run s@SQLAPI_Msg delay:1t 'def:<&c>Not multiplying %flagName% for %owner%! Current value %flagVal% is not numeric!'
        - queue clear
        }
      }

    - if %type% == server {
      - if %flagExists% {
        - if %isExpired% {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
          }
          else {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = value * '%flagValue%' WHERE flag='%flagName%';"
          }
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - if %isExpired% {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
          }
          else {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = value * '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
          }
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

  divide_flag:
    - if %flagValue% !matches decimal {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>%flagValue% is not a valid number! Not dividing %flagName% for %owner%!'
      - queue clear
      }
    - if %flagValue% == 0 {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>Can not divide by 0! Not dividing %flagName% for %owner%!'
      - queue clear
      }
    - define yamlName 'SQLAPI'
    - define scriptName 'SQLAPI'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flagName%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - run s@SQLAPI_Msg delay:1t 'def:<&c>System Offline! Can not divide %flagName% for %owner% by %flagValue% in %tableName%!'
      - queue clear
      }
    - if %record% != null {
      - define flagExists 'true'
      - define expires '<def[record].get[3].unescaped||0>'
      - if %expires% == 0 || %expires% > <server.current_time_millis> {
        - define isExpired 'false'
        }
        else {
        - define isExpired 'true'
        }
      }
      else {
      - define flagExists 'false'
      - define isExpired 'true'
      }

    - if %flagExists% {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if %flagVal% !matches decimal {
        - run s@SQLAPI_Msg delay:1t 'def:<&c>Not dividing %flagName% for %owner%! Current value %flagVal% is not numeric!'
        - queue clear
        }
      }

    - if %type% == server {
      - if %flagExists% {
        - if %isExpired% {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%';"
          }
          else {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = value / '%flagValue%' WHERE flag='%flagName%';"
          }
        }
        else {
        - define statement "INSERT INTO %tableName% (flag, value, expiration) VALUES ('%flagName%', '%flagValue%', '%expiration%');"
        }
      }
      else {
      - define uuid '<tern[<def[type].is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - if %flagExists% {
        - if %isExpired% {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
          }
          else {
          - define statement "UPDATE %tableName% SET expiration = '%expiration%', value = value / '%flagValue%' WHERE flag='%flagName%' AND uuid='%uuid%';"
          }
        }
        else {
        - define statement "INSERT INTO %tableName% (uuid, flag, value, expiration) VALUES ('%uuid%', '%flagName%', '%flagValue%', '%expiration%');"
        }
      }
    - inject s@SQLManager_Offline p:managedUpdateStatement

#########################
# Command messages
  msg_set:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Set <def[flagName].unescaped> to <def[flagValue].replace[|].with[`]> for %owner%<tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'

  msg_clear:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Cleared <def[flagName].unescaped> for %owner%'

  msg_set_list:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Set list flag <def[flagName].unescaped> to <def[flagValue].replace[|].with[`].after[`]> for %owner%<tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'

  msg_set_index:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Set <def[flagName].unescaped> list to <def[flagValue].replace[|].with[`].after[`]> starting at index %index% for %owner%<tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'

  msg_include:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Included <def[flagValue].replace[|].with[`].after[`]> in <def[flagName].unescaped> list for %owner%<tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'

  msg_insert_index:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Included <def[flagValue].replace[|].with[`].after[`]> in <def[flagName].unescaped> list starting at index %index% for %owner%<tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'

  msg_remove:
    - if <def[flagValue].is[==].to[<&pipe>]> {
      - run s@SQLAPI_Msg delay:1t 'def:<&7>Cleared <def[flagName].unescaped> for %owner%'
      }
      else {
      - run s@SQLAPI_Msg delay:1t 'def:<&7>Removed <def[flagValue].replace[|].with[`].after[`]> from <def[flagName].unescaped> list for %owner%<tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'
      }

  msg_increment:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Increased <def[flagName].unescaped> for %owner% by <def[flagValue].unescaped><tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'

  msg_decrement:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Decreased <def[flagName].unescaped> for %owner% by <def[flagValue].unescaped><tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'

  msg_multiply:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Multiplied <def[flagName].unescaped> for %owner% by <def[flagValue].unescaped><tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'

  msg_divide:
    - run s@SQLAPI_Msg delay:1t 'def:<&7>Divided <def[flagName].unescaped> for %owner% by <def[flagValue].unescaped><tern[<def[expiration].is[==].to[0]>]:<&dot>||<&dot> Expires in <def[duration].split[<&co>].get[2].as_duration.formatted><&dot>>'



SQLAPI_ParseOwner:
# Usage: <proc[SQLAPI_ParseOwner].context[owner]||null>
  type: procedure
  debug: false
  definitions: owner
  script:
    - define owner "<parse:<def[owner]>>"
    - inject locally <def[owner].type||null>
    - announce to_console "<&b>SQLAPI<&co><&c> Must specify valid owner object!"
    - announce to_console "<&b>SQLAPI<&co><&c> Can not parse %owner%"

  player:
    - determine 'player'

  entity:
    - determine 'entity'

  npc:
    - determine 'npc'

  element:
    - if %owner% == server {
      - determine 'server'
      }
      else if %owner% == player {
      - determine 'thisPlayer'
      }

SQLAPI_GetFlagRecord:
# Usage: <proc[SQLAPI_GetFlagRecord].context[owner|flag]||null>
  type: procedure
  debug: false
  definitions: owner|flag
  script:
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if li@player|entity|npc|server !contains %type% {
      - announce to_console "<&b>SQLAPI<&co> <&c>Invalid type specified in flag lookup!"
      - announce to_console "<&b>SQLAPI<&co> <&b>Attempted<&co> %owner% %type% %flag%"
      - queue clear
      }
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - if !<proc[SQLManager_ConnectionCheck].context[%db%]> {
      - announce to_console "<&b>SQLAPI<&co> <&c>Database Offline!"
      - yaml set 'id:SQLManager_Offline' 'Offline_Cache.databases.%db%.status:offline'
      - yaml 'savefile:SQLManager/cache.yml' 'id:SQLManager_Offline'
      - run s@SQLManager p:restart def:SQLAPI|SQLAPI|%db%
      - determine 'SQLAPI OFFLINE'
      }
    - if %owner% == server {
      - sql id:%db% "query:SELECT flag,value,expiration FROM %tablename% WHERE flag='%flag%';" save:record
      }
      else {
      - define uuid '<tern[<def[owner].type.is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - sql id:%db% "query:SELECT flag,value,expiration FROM %tablename% WHERE flag='%flag%' AND uuid='%uuid%';" save:record
      }
    - define record '<entry[record].result>'
    - if <def[record].size> == 1 {
      - determine '<entry[record].result.get[1].split[/]||null>'
      }
    - if <def[record].size> != 0 {
      - announce to_console "<&b>SQLAPI<&co> <&c>%tablename% has <def[record].size> records of %flag% for %uuid%!"
      - announce to_console "<&b>SQLAPI<&co> <&c>Only returning the first record!"
      - determine '<entry[record].result.get[1].split[/]||null>'
      }


SQLAPI_FlagExists:
# Usage: <proc[SQLAPI_FlagExists].context[owner|flag]>
  type: procedure
  debug: false
  definitions: owner|flag
  script:
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flag%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - queue clear
      }
    - if %record% != null {
      - determine 'true'
      }
    - determine 'false'


SQLAPI_IsExpired:
# Usage: <proc[SQLAPI_IsExpired].context[owner|flag]>
  type: procedure
  debug: false
  definitions: owner|flag
  script:
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flag%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - queue clear
      }
    - if %record% != null {
      - define expiration '<def[record].get[3].unescaped||null>'
      - if %expiration% == 0 || %expiration% > <server.current_time_millis> {
        - determine 'false'
        }
      }
    - determine 'true'


SQLAPI_Expiration:
# Usage: <proc[SQLAPI_Expiration].context[owner|flag]>
  type: procedure
  debug: false
  definitions: owner|flag
  script:
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flag%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - queue clear
      }
    - if %record% != null {
      - define expiration '<def[record].get[3].unescaped||null>'
      - if %expiration% == 0 {
        - determine '<el@val[0].as_duration>'
        }
      - if %expiration% > <server.current_time_millis> {
        - determine '<el@val[<def[expiration].sub_int[<server.current_time_millis>].div[1000]>s].as_duration>'
        }
      }


SQLAPI_HasFlag:
# Usage: <proc[SQLAPI_HasFlag].context[owner|flag]>
  type: procedure
  debug: false
  definitions: owner|flag
  script:
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flag%]||null>'
    - if '<def[record].equals_case_sensitive[SQLAPI OFFLINE]>' {
      - queue clear
      }
    - if %record% != null {
      - define expiration '<def[record].get[3].unescaped||0>'
      - if %expiration% == 0 || %expiration% > <server.current_time_millis> {
        - determine 'true'
        }
      }
    - determine 'false'


SQLAPI_GetFlag:
# Usage: <proc[SQLAPI_GetFlag].context[owner|flag]||null>
  type: procedure
  debug: false
  definitions: owner|flag
  script:
    - define record '<proc[SQLAPI_GetFlagRecord].context[%owner%|%flag%]||null>'
    - if %record% == null || <def[record].equals_case_sensitive[SQLAPI OFFLINE]> {
      - queue clear
      }
    - define expiration '<def[record].get[3].unescaped||0>'
    - if %expiration% == 0 || %expiration% > <server.current_time_millis> {
      - define flagVal '<def[record].get[2].unescaped||null>'
      - if <def[flagVal].starts_with[|]> {
        - define flagVal '<def[flagVal].as_list>'
        - determine '<def[flagVal].get[2].to[<def[flagVal].size>]>'
        }
        else {
        - determine '%flagVal%'
        }
      }


SQLAPI_ListFlags:
# Usage: <proc[SQLAPI_ListFlags].context[owner]||null>
  type: procedure
  debug: false
  definitions: owner
  script:
    - define type '<proc[SQLAPI_ParseOwner].context[%owner%]||null>'
    - if li@player|entity|npc|server !contains %type% {
      - announce to_console "<&b>SQLAPI<&co> <&c>Invalid type specified in flag lookup!"
      - announce to_console "<&b>SQLAPI<&co> <&b>Attempted<&co> %owner% %type%"
      - queue clear
      }
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - if !<proc[SQLManager_ConnectionCheck].context[%db%]> {
      - announce to_console "<&b>SQLAPI<&co> <&c>Database Offline!"
      - yaml set 'id:SQLManager_Offline' 'Offline_Cache.databases.%db%.status:offline'
      - yaml 'savefile:SQLManager/cache.yml' 'id:SQLManager_Offline'
      - run s@SQLManager p:restart def:SQLAPI|SQLAPI|%db%
      - determine 'SQLAPI OFFLINE'
      }
    - define now '<server.current_time_millis>'
    - if %owner% == server {
      - sql id:%db% "query:SELECT flag FROM %tablename% WHERE expiration>'%now%' OR expiration='0';" save:record
      }
      else {
      - define uuid '<tern[<def[owner].type.is[==].to[npc]>]:<def[owner].id>||<def[owner].uuid>>'
      - sql id:%db% "query:SELECT flag FROM %tablename% WHERE uuid='%uuid%' AND (expiration>'%now%' OR expiration='0');" save:record
      }
    - determine '<entry[record].result.parse[before[/]]>'


SQLAPI_GetFlagged:
# Usage: <proc[SQLAPI_GetFlagged].context[type|flag]||null>
  type: procedure
  debug: false
  definitions: type|flag
  script:
    - if li@player|entity|npc !contains %type% {
      - announce to_console "<&b>SQLAPI<&co> <&c>Invalid type specified in flag lookup!"
      - announce to_console "<&b>SQLAPI<&co> <&b>Attempted<&co> %owner% %type%"
      - queue clear
      }
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - if !<proc[SQLManager_ConnectionCheck].context[%db%]> {
      - announce to_console "<&b>SQLAPI<&co> <&c>Database Offline!"
      - yaml set 'id:SQLManager_Offline' 'Offline_Cache.databases.%db%.status:offline'
      - yaml 'savefile:SQLManager/cache.yml' 'id:SQLManager_Offline'
      - run s@SQLManager p:restart def:SQLAPI|SQLAPI|%db%
      - determine 'SQLAPI OFFLINE'
      }
    - define now '<server.current_time_millis>'
    - sql id:%db% "query:SELECT uuid FROM %tablename% WHERE flag='%flag%' AND (expiration>'%now%' OR expiration='0');" save:record
    - determine '<entry[record].result.parse[before[/]].parse[as_%type%]>'


SQLAPI_GetCurrentFlagged:
# Usage: <proc[SQLAPI_GetCurrentFlagged].context[type|flag]||null>
  type: procedure
  debug: false
  definitions: type|flag
  script:
    - if li@player|entity|npc !contains %type% {
      - announce to_console "<&b>SQLAPI<&co> <&c>Invalid type specified in flag lookup!"
      - announce to_console "<&b>SQLAPI<&co> <&b>Attempted<&co> %owner% %type%"
      - queue clear
      }
    - define tableName '<yaml[SQLAPI_config].read[config.MySQL.tables.%type%SQLFLags]||dsqlapi_%type%sqlflags>'
    - define db '<yaml[SQLAPI_config].read[config.MySQL.database]||SQLAPI>'
    - if !<proc[SQLManager_ConnectionCheck].context[%db%]> {
      - announce to_console "<&b>SQLAPI<&co> <&c>Database Offline!"
      - yaml set 'id:SQLManager_Offline' 'Offline_Cache.databases.%db%.status:offline'
      - yaml 'savefile:SQLManager/cache.yml' 'id:SQLManager_Offline'
      - run s@SQLManager p:restart def:SQLAPI|SQLAPI|%db%
      - determine 'SQLAPI OFFLINE'
      }
    - define now '<server.current_time_millis>'
    - sql id:%db% "query:SELECT uuid FROM %tablename% WHERE flag='%flag%' AND (expiration>'%now%' OR expiration='0');" save:record
    - if %type% == player {
      - determine '<entry[record].result.parse[before[/]].parse[as_%type%].filter[is_online]>'
      }
      else {
      - determine '<entry[record].result.parse[before[/]].parse[as_%type%].filter[is_spawned]>'
      }


SQLAPI_LineWrap:
  # Turn a long string into a list of smaller strings
  type: procedure
  definitions: string|targetLen
  speed: 0
  debug: false

  script:
    - define stringLen '<def[string].length>'
    - if <def[stringLen].is[MORE].than[%targetLen%]> {
      - define lines 'li@'
      - while <def[stringLen].is[MORE].than[0]> {
        - define low '<def[increment].add[1].as_int||1>'
        - define hi '<def[increment].add[<def[targetLen].add[1]>].as_int||%targetLen%>'
        - define pass '<el@val[%string%].substring[%low%,%hi%]>'
        - if <def[pass].length.is[==].to[%stringLen%]> {
          - define lines '<def[lines].include[<el@val[%pass%]>]||<def[lines]>>'
          - while stop
          }
          else {
          - define brake '<def[pass].last_index_of[ ]>'
          - define increment '<def[increment].add[%brake%]||%brake%>'
          - define passtrim '<el@val[<def[pass].substring[1,<t[<def[brake].is[MORE].than[0]>]:%brake%||<def[pass].length>>]>]>'
          - define lines '<def[lines].include[<el@val[%passtrim%]>]||<def[lines]>>'
          - define stringLen '<def[stringLen].sub[%brake%]>'
          }
        - if <def[loop_index].is[MORE].than[10]> {
          - while stop
          }
        }
      - determine '<def[lines].as_list>'
      }
      else {
      - determine '<def[string].as_list>'
      }


SQLAPI_Msg:
  type: item
  speed: 0
  debug: false
  material: i@human_skull
  display name: "<&4>  [<&6>SQPAPI<&4>]"
  lore:
  - <&5>Click for Help
  script:
    - ^define text '<&4>[<&6>SQPAPI<&4>]'
    - ^define hover '<&chr[007B]><i@SQLAPI_Msg.json><&chr[007D]>'
    - ^define click '/SQPAPI help'
    - ^define button "text:'%text%',clickEvent:<&chr[007B]>action:run_command,value:'%click%'<&chr[007D]>,hoverEvent:<&chr[007B]>action:show_item,value:'%hover%'<&chr[007d]>"
    - ^define spacer "text:'  '"
    - ^define color '<&f>'
    - ^define colorCheck '<def[1].substring[1,2]>'
    - ^if <def[colorCheck].starts_with[<&ss>]> {
      - define colorCheck '<def[colorCheck].replace[<&ss>]>'
      - if <def[colorCheck].matches[[0-9a-fA-Fk-oK-OrR]]> {
        - define color '<&%colorCheck%>'
        }
      }
    - ^if <player.is_player||false> {
      - define lines '<proc[SQLAPI_LineWrap].context[%1%|45]>'
      - foreach <def[lines]> {
        - define msg "text:'%color%<def[value].replace[`].with[<&pipe>]>'"
        - execute as_server "tellraw <player.name> <&chr[007B]>text:'',extra:[<&chr[007B]>%button%<&chr[007D]>,<&chr[007B]>%spacer%<&chr[007D]>,<&chr[007B]>%msg%<&chr[007D]>]<&chr[007D]>"
        }
      }
    - ^announce to_console "<&4><&lb><&6>SQPAPI<&4><&rb> %1%"

################################################################################
#                                                                              #
# Configuration Files                                                          #
#                                                                              #
#   These are the default config files. They will be used to build the default #
# config file and data storage files.                                          #
#                                                                              #
#______________________________________________________________________________#
#                                                                              #
#______________________________DO_NOT_EDIT_THIS_DATA___________________________#
#______________________________________________________________________________#


SQLAPI_Configurations:
  type: yaml data
  debug: false

  config:
    MySQL:
      useSql: false
      connection:
        keepAlive: 5m
        retry: 3
        retryDelay: 10s
        host: localhost
        port: 3306
        username: root
        password: password
      database: SQLAPI
      tables:
        PlayerSQLFLags: dsqlapi_playersqlflags
        NPCSQLFLags: dsqlapi_npcsqlflags
        EntitySQLFLags: dsqlapi_entitysqlflags
        ServerSQLFLags: dsqlapi_serversqlflags


################################################################################
#                                                                              #
# SQL Table Structure                                                          #
#                                                                              #
#   This is where the table structure is defined. It would be best if you do   #
# not touch anything in this section!                                          #
#                                                                              #
#______________________________________________________________________________#
#                                                                              #
#______________________________DO_NOT_EDIT_THIS_DATA___________________________#
#______________________________________________________________________________#


SQLAPI_SQLTables:
# This script gets injected from the SQLManager on system start. It sets up some
# data it needs and loads the table structure so it's ready for the SQLManager.
  type: task
  debug: false

  script:
    - define sqlScriptName '<script.name>'
    - define sqlFile '<script.relative_filename>'
    - if <yaml.list.contains[%sqlScriptName%]> yaml unload 'id:%sqlScriptName%'
    - yaml 'load:%sqlFile%' fix_formatting 'id:%sqlScriptName%'
    - if !<yaml.list.contains[%sqlScriptName%]> {
      - announce "<&c>SQLAPI<&co><&b> An error occurred while loading %sqlScriptname%!" to_console
      - announce "<&b>SQLAPI<&co><&3> Aborting..." to_console
      - inject s@%scriptName% p:unload
      - queue stop
      }

  tables:
    PlayerSQLFLags:
      columns:
        id: INT AUTO_INCREMENT PRIMARY KEY
        uuid: varchar(36)
        flag: BLOB
        value: MEDIUMBLOB
        expiration: BIGINT
    NPCSQLFLags:
      columns:
        id: INT AUTO_INCREMENT PRIMARY KEY
        uuid: varchar(36)
        flag: BLOB
        value: MEDIUMBLOB
        expiration: BIGINT
    EntitySQLFLags:
      columns:
        id: INT AUTO_INCREMENT PRIMARY KEY
        uuid: varchar(36)
        flag: BLOB
        value: MEDIUMBLOB
        expiration: BIGINT
    ServerSQLFLags:
      columns:
        id: INT AUTO_INCREMENT PRIMARY KEY
        flag: BLOB
        value: MEDIUMBLOB
        expiration: BIGINT


#