html复制代码<div class="slide">
  <div class="slide-list">
    <slot></slot>
  </div>
</div>

html复制代码.slide {
  touch-action: none;
  height: 100%;
  width: 100%;
  transition: height 0.3s;
  position: relative;
  overflow: hidden;
}

 .slide-list {
    height: 100%;
    width: 100%;
    display: flex;
    position: relative;
  }

html复制代码<div class="slide horizontal">
  <div
      class="slide-list"
      ref="wrapperEl"
      @pointerdown="onPointerDown"
      @pointermove="onPointerMove"
      @pointerup="onPointerUp"
  >
    <slot></slot>
  </div>
</div>

js复制代码//slide-list的ref引用
const wrapperEl = ref(null)

const state = reactive({
  judgeValue: 20,//一个用于判断滑动朝向的固定值
  type: SlideType.VERTICAL,//组件类型
  name: props.name,
  localIndex: props.index,//当前下标
  needCheck: true,//是否需要检测，每次按下都需要检测，up事件会重置为true
  next: false,//能否滑动
  isDown: false,//是否按下，用于move事件判断
  start: {x: 0, y: 0, time: 0},//按下时的起点坐标
  move: {x: 0, y: 0},//移动时的坐标
  wrapper: {width: 0, height: 0, childrenLength: 0}//slide-list的宽度和子元素数量
})

js复制代码function slidePointerDown(e, el, state) {
  Utils.$setCss(el, 'transition-duration', `0ms`)
  //记录起点坐标，用于move事件计算移动距离
  state.start.x = e.pageX
  state.start.y = e.pageY
  //记录按下时间，用于up事件判断滑动时间
  state.start.time = Date.now()
  state.isDown = true
}

js复制代码function slidePointerMove(e,el,state) {
  if (!state.isDown) return;

  //计算移动距离
  state.move.x = e.pageX - state.start.x
  state.move.y = e.pageY - state.start.y

  //检测能否滑动
  let canSlideRes = canSlide(state)

  //是否是往下（右）滑动
  let isNext = state.type === SlideType.HORIZONTAL ? state.move.x < 0 : state.move.y < 0

  if (canSlideRes) {
    if (canNext(state, isNext)) {
      //能滑动，那就把事件捕获，不能给父组件处理
      Utils.$stopPropagation(e)

      //获取偏移量
      let t = getSlideOffset(state, el) + (isNext ? state.judgeValue : -state.judgeValue)
      let dx1 = 0,
        dx2 = 0
      //偏移量加当前手指移动的距离就是slide要偏移的值
      if (state.type === SlideType.HORIZONTAL) {
        dx1 = t + state.move.x
      } else {
        dx2 = t + state.move.y
      }
      Utils.$setCss(el, 'transition-duration', `0ms`)
      Utils.$setCss(el, 'transform', `translate(${dx1}px, ${dx2}px)`)
    }
  }
}

js复制代码//检测在对应方向上能否允许滑动，比如SlideHorizontal组件就只处理左右滑动事件，SlideVertical 
//只处理上下滑动事件 
export function canSlide(state) {
  //每次按下都需要检测，up事件会重置为true
  if (state.needCheck) {
    //判断move x和y的距离是否大于判断值，因为距离太小无法判断滑动方向
    if (Math.abs(state.move.x) > state.judgeValue || Math.abs(state.move.y) > state.judgeValue) {
      //放大再相除，根据长宽比判断方向，angle大于1就是左右滑动，小于是上下滑动
      let angle = (Math.abs(state.move.x) * 10) / (Math.abs(state.move.y) * 10)
      //根据当前slide的类型，判断能否滑动，并记录下来，后续不再判断，直接返回记录值
      state.next = state.type === SlideType.HORIZONTAL ? angle > 1 : angle <= 1
      state.needCheck = false
    } else {
      return false
    }
  }
  return state.next
}

js复制代码function canNext(state, isNext) {
  return !(
    (state.localIndex === 0 && !isNext) ||
    (state.localIndex === state.wrapper.childrenLength - 1 && isNext)
  )
}

js复制代码//检测在对应方向上能否允许滑动
let canSlideRes = canSlide(state)
//是否是往下（右）滑动
let isNext = state.type === SlideType.HORIZONTAL ? state.move.x < 0 : state.move.y < 0
if (canSlideRes) {
  if (canNext(state, isNext)) {
    //能滑动，那就把事件捕获，不能给父组件处理
    Utils.$stopPropagation(e)
    ...
    滑动逻辑
    ...
  }
}

js复制代码function slidePointerUp(e, state) {
  if (!state.isDown) return;
  let isHorizontal = state.type === SlideType.HORIZONTAL
  let isNext = isHorizontal ? state.move.x < 0 : state.move.y < 0
  if (state.next) {
    if (canNext(state, isNext)) {
      //结合时间、距离来判断是否成功滑动
      let endTime = Date.now()
      let gapTime = endTime - state.start.time
      let distance = isHorizontal ? state.move.x : state.move.y
      let judgeValue = isHorizontal ? state.wrapper.width : state.wrapper.height
      //1、距离太短，直接不通过
      if (Math.abs(distance) < 20) gapTime = 1000
      //2、距离太长，直接通过
      if (Math.abs(distance) > judgeValue / 3) gapTime = 100
      //3、若不在上述两种情况，那么只需要判断时间即可
      if (gapTime < 150) {
        if (isNext) state.localIndex++
        else state.localIndex--
      }
    }
  } 
  // 重置变量
  Utils.$setCss(el, 'transition-duration', `300ms`)
  let t = getSlideOffset(state, el)
  let dx1 = 0,dx2 = 0
  if (state.type === SlideType.HORIZONTAL) dx1 = t
  else dx2 = t
  Utils.$setCss(el, 'transform', `translate3d(${dx1}px, ${dx2}px, 0)`)
  ...
}

js复制代码@dragstart="(e) => Utils.$stopPropagation(e)"

js复制代码window.isMoved = false

js复制代码window.isMoved = false
HTMLElement.prototype.addEventListener = new Proxy(HTMLElement.prototype.addEventListener, {
  apply(target, ctx, args) {
    const eventName = args[0]
    const listener = args[1]
    if (listener instanceof Function && eventName === 'click') {
      args[1] = new Proxy(listener, {
        apply(target, ctx, args) {
          if (window.isMoved) return
          try {
            return target.apply(ctx, args)
          } catch (e) {
            console.error(`[proxyPlayerEvent][${eventName}]`, listener, e)
          }
        }
      })
    }
    return target.apply(ctx, args)
  }
})

java复制代码/**简化代码，只保留主要流程信息，
*从监控平台获取相关服务数据，并转化为压测模型保存在压测平台
*/
public PressureModel getAndSaveOneDayMonitorData(String appId, String env, String name, String batchId, long start, long end, long step, MonitorData orderMonitorData) {
    PressureModel model = new PressureModel();
    String timeScope = StrUtil.isEmpty(orderMonitorData.getTimeScope()) ? MonitorData.TIME_ALL_DAY : MonitorData.TIME_CUSTOM;
    //soa监控数据获取并转换模型
    HashMap<String, MetricIntegratorData> monitorQpsSoaData = getMonitorQpsSoaData(env, appId, false, start, end, step);
    List<MonitorData> monitorQpsSoaDataFromMetricDates = getMonitorDataFromMetricDates(appId, env, name, batchId, MonitorData.TYPE_QPS_SOA, MonitorData.TYPE_QPS_SOA, timeScope, monitorQpsSoaData);
    if (!monitorQpsSoaDataFromMetricDates.isEmpty()) {
        monitorDataRepository.saveAll(monitorQpsSoaDataFromMetricDates);
        model = MonitorDataUtil.transitionPressureModel(model, monitorQpsSoaDataFromMetricDates, orderMonitorData);
    }
    //获取其它关键信息如SOA，CPU，Mysql,Redis等，均保存到模型model中。
    pressureModelRepository.save(model);
 }

java复制代码public abstract class AbstractTaskNodeService implements TaskNodeService {
    protected TaskNode taskNode;

    public AbstractTaskNodeService(TaskNode taskNode) {
//代码已简化
        this.taskNode = taskNode;
        init();
        preExecute();
        execute();
        postProcessor();
    }

    @Override
    public void init() {
//解析出对应的上下文，及数据处理工作
    }

    @Override
    public void preExecute() {
//执行预处理动作，包括获取兄弟节点任务
    }

    @Override
    public void execute() {
//执行任务，每一种任务类重写
    }

    @Override
    public void postProcessor() {
//保存状态，生成下一节点任务
    }

    @Override
    public TaskNode getTaskNode() {
        return this.taskNode;
    }

}

java复制代码//压测机初步收集汇总本机数据，并发送到kafka
@Slf4j
public class HllBackendListenerClient extends AbstractBackendListenerClient {
    @Override
    public void setupTest(BackendListenerContext backendListenerContext) throws Exception {
        //压测设置项
    }

    @Override
    public void handleSampleResults(List<SampleResult> list, BackendListenerContext backendListenerContext) {
        //压测数据处理并发送
    }

    @Override
    public void teardownTest(BackendListenerContext backendListenerContext) throws Exception {
        analysis();
        schedule.shutdown();
    }

    private void analysis() {
    //压测机初步数据统计
        Collector<YiSample, SampleState, SampleState> c = Collector.of(
                SampleState::new,
                SampleState::accumulator,
                SampleState::combiner,
                SampleState::finisher
        );
        Map<String, SampleState> sampleStateMap = temp.stream()
                .collect(Collectors.groupingBy(YiSample::getLabel, c));
    }
}

java复制代码//收集服务消费KAFKA并统一汇总数据
@Slf4j
public class AnalysisProcessor implements Processor<String, String> {
    private ProcessorContext context;
    private AtomicInteger processorNumber = new AtomicInteger();
    PerformanceRecordRepository performanceRecordRepository = SpringContextUtils.getBean(PerformanceRecordRepository.class);
    ReportRepository reportRepository = SpringContextUtils.getBean(ReportRepository.class);
    private ConcurrentHashMap<String, List<SampleState>> sampleMap = new ConcurrentHashMap<>();

    @Override
    public void init(ProcessorContext context) {
        //1.初始化
        this.context = context;
        processorNumber.getAndIncrement();
if (processorNumber.get() <= 1) {
            this.context.schedule(Report.REPORT_INTERVAL, PunctuationType.WALL_CLOCK_TIME, (timeStamp) -> analysis());
            log.info("init AnalysisProcessor");
        }
    }

    @Override
    public void process(String key, String message) {
        //2.压测数据处理
        SampleState sampleState = JSON.parseObject(message, SampleState.class);
        if (!sampleMap.containsKey(key)) {
            List<SampleState> list = new ArrayList<>();
            sampleMap.put(key, list);
        }
        sampleMap.get(key).add(sampleState);
    }

    @Override
    public void close() {
    }

    private void analysis() {
        sampleMap.forEach((reportId, sampleStates) -> {
            if (sampleStates.size() == 0) {
                sampleMap.remove(reportId);
            }
            long start = System.currentTimeMillis();
            Collector<SampleState, PerformanceRecordState, PerformanceRecord> c = Collector.of(
                    PerformanceRecordState::new,
                    PerformanceRecordState::accumulator,
                    PerformanceRecordState::combiner,
                    PerformanceRecordState::finisher
            );
            //汇总性能数据
            Map<String, PerformanceRecord> reportRecord = sampleStates.stream()
                    .collect(Collectors.groupingBy(SampleState::getLabel, c));
            AtomicInteger i = new AtomicInteger();
            reportRecord.forEach((label, record) -> {
                PerformanceRecord saveRecord = performanceRecordRepository.save(record);
                i.getAndAdd((int) saveRecord.getN());
            });

            log.info("analysis report:{} once,it has {} record ,and {} samples ,used:{}ms ", reportId, sampleStates.size(), i.get(), (System.currentTimeMillis() - start));
            //清空此批数据
            if (sampleMap.containsKey(reportId)) {
                sampleMap.get(reportId).clear();
            }
        });

    }

}

SELECT * FROM performance_schema.metadata_locks;

python复制代码    def signChat(self,history):
        history_openai_format = []
        # 先加入系统信息
        history_openai_format.append(
            {"role": "system",
             "content": Config.settings.get("system_xiaoxi")
             },
        )
        # 再加入解析信息
        history_openai_format.extend(history)
        # print(history_openai_format)
        completion = client.chat.completions.create(
            model=Config.settings.get("default_model"),
            messages=history_openai_format,
            temperature=Config.settings.get("temperature"),
        )
        result = completion.choices[0].message.content
        return result

python复制代码    "system_xiaoxi": "你是一个全能小助手，你的名字叫小汐，尤其擅长写作和故事改编。"

python复制代码import time
from openai import OpenAI

from utils import Config
api_key = Config.settings.get("openai_api_key")
client = OpenAI(api_key=api_key,base_url=Config.settings.get("openai_api_base"))


class ChatBotHandler(object):
    def __init__(self, bot_name="chat"):
        self.bot_name = bot_name
        self.current_message = None


    def user_stream(self,user_message, history):
        self.current_message = user_message
        return "", history + [[user_message, None]]

    def bot_stream(self,history):

        if(len(history)==0):
            history.append([self.current_message,None])
        bot_message = self.getResponse(history[-1][0],history)
        history[-1][1] = ""
        for character in bot_message:
            history[-1][1] += character
            time.sleep(0.02)
            yield history

    def signChat(self,history):
        history_openai_format = []
        # 先加入系统信息
        history_openai_format.append(
            {"role": "system",
             "content": Config.settings.get("system_xiaoxi")
             },
        )
        # 再加入解析信息
        history_openai_format.extend(history)
        # print(history_openai_format)
        completion = client.chat.completions.create(
            model=Config.settings.get("default_model"),
            messages=history_openai_format,
            temperature=Config.settings.get("temperature"),
        )
        result = completion.choices[0].message.content
        return result

    def getResponse(self,message,history):
        history_openai_format = []
        for human, assistant in history:
            # 基础对话的系统设置
            history_openai_format.append(
                {"role": "system",
                 "content":Config.settings.get("system_xiaoxi")
                },
            )
            if(human!=None):
                history_openai_format.append({"role": "user", "content": human})
            if(assistant!=None):
                history_openai_format.append({"role": "assistant", "content": assistant})

        completion = client.chat.completions.create(
            model=Config.settings.get("default_model"),
            messages=history_openai_format,
            temperature=Config.settings.get("temperature"),
        )
        result = completion.choices[0].message.content
        return result


    def chat(self,message, history):
        history_openai_format = []
        for human, assistant in history:
            history_openai_format.append({"role": "user", "content": human})
            history_openai_format.append({"role": "system", "content": assistant})
        history_openai_format.append({"role": "user", "content": message})

        response = client.chat.completions.create(model="moonshot-v1-8k",
                                                  messages=history_openai_format,
                                                  temperature=1.0,
                                                  stream=True)

        partial_message = ""
        for chunk in response:
            if chunk.choices[0].delta.content is not None:
                partial_message = partial_message + chunk.choices[0].delta.content
                yield partial_message

python复制代码import requests
import json

config = getConfig()

class MyOpenAI():

    def __init__(self):
        self.url = "https://api.openai-hk.com/v1/chat/completions"

        self.headers = {
            "Content-Type": "application/json",
            # 这里采用的是中转站的openai key
            "Authorization": "Bearer "+config.get("image_api_key")
        }

    def chat(self,message,prompt,temperature=0.8):
        data = {
            "max_tokens": 1200,
            "model": "gpt-3.5-turbo",
            "temperature": temperature,
            "top_p": 1,
            "presence_penalty": 1,
            "messages": [
                {
                    "role": "system",
                    "content":prompt
                },
                {
                    "role": "user",
                    "content": message
                }
            ]
        }

        response = requests.post(self.url, headers=self.headers, data=json.dumps(data).encode('utf-8'))
        result = response.content.decode("utf-8")
        result = json.loads(result)
        result = result["choices"][0]["message"]["content"]
        return result

python复制代码
class Text2Image():
    def __init__(self):
        # 构建请求头
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }

        self.current_file_path = os.path.abspath(__file__)
        self.current_dir = os.path.dirname(self.current_file_path)
        self.resource_dir = self.current_dir+"/../resource"

    def get_taskId(self,prompt):

        def send(prompt,headers):
            data = {
                "base64Array": [],
                "instanceId": "",
                "modes": [],
                "notifyHook": "https://ww.baidu.com/notifyHook/back",
                "prompt": prompt,
                "remix": True,
                "state": ""
            }

            response = requests.post(
                url='https://api.openai-hk.com/fast/mj/submit/imagine',
                headers=headers,
                data=json.dumps(data)
            )
            return response.json()
        try:
            result = send(prompt, self.headers)
        except Exception as e:
            result = {'code':-1}
        if result.get('code') == 1:
            return result.get("result")
        else:
            return None

    #1713283471368561
    def get_Image(self,task_id):
        url = f'https://api.openai-hk.com/fast/mj/task/{task_id}/fetch'

        # 发送GET请求
        response = requests.get(url, headers=self.headers)
        return response.json()

    def __create_img_stream(self):

        now = datetime.now()
        year_month_day = now.strftime("%Y%m%d")
        file_uuid = uuid.uuid4()
        audio_stream = self.resource_dir + "/img" + "/" + year_month_day + "/"
        if (not os.path.exists(audio_stream)):
            os.makedirs(audio_stream)
        audio_stream += file_uuid.hex + ".jpg"
        return audio_stream


    def __getImg(self,url):
        response = requests.get(url)
        response.raise_for_status()
        image = Image.open(BytesIO(response.content))
        width, height = image.size
        quarter_width = width // 2
        quarter_height = height // 2
        # 裁剪左上角的四分之一图片
        cropped_image = image.crop((0, 0, quarter_width, quarter_height))
        return cropped_image


    # 只要这个任务执行失败，那么我们就返回为空
    def text2image(self,prompt):
        # 先拿到task_id
        task_id = self.get_taskId(prompt)
        if(task_id):
            return self.__text2image(prompt,task_id)
        else:
            return None

    def __text2image(self,prompt,task_id):

        res = self.get_Image(task_id)
        # 执行失败
        if(res.get("status")=="FAILURE"):
            return None
        if(res.get('progress') == "100%"):
            return self.__getImg(res.get("imageUrl"))
        else:
            # 还在生成，等待一会再去重试呗,调用api生成还是比较慢的
            time.sleep(2)
            return self.__text2image(prompt,task_id)

json复制代码       response_data = {
        'id': '1713283927285806',
        'properties': {
            'discordChannelId': '1222483390712774667',
            'botType': 'MID_JOURNEY',
            'notifyHook': 'https://www.open-hk.com/openai/mjapi/16158-567/https%3A%2F%2Fww.baidu.com%2FnotifyHook%2Fback',
            'discordInstanceId': '1500442604632883200',
            'flags': 0,
            'messageId': '1229828231935426650',
            'messageHash': 'b1290620-0d25-4882-a72d-102dc174fc22',
            'nonce': '1501375981829570560',
            'finalPrompt': 'a black cat',
            'progressMessageId': '1229827516609331220',
            'messageContent': '**a black cat** - <@1222482757389910027> (fast)'
        },
        'action': 'IMAGINE',
        'status': 'SUCCESS',
        'prompt': 'a black cat',
        'promptEn': 'a black cat',
        'description': '/imagine a black cat',
        'submitTime': 1713283927285,
        'startTime': 1713284128607,
        'finishTime': 1713284300009,
        'progress': '100%',
        'imageUrl': 'https://proxy.xjai.top:33330/mjcdn/attachments/1222483390712774667/1229828230979129374/xizaizai0902_a_black_cat_b1290620-0d25-4882-a72d-102dc174fc22.png?ex=663119cb&is=661ea4cb&hm=1657fcc1bfd3f971fd2d9349ee8b5442a2b300f95e13ab72cee662d76e09789a&',
        'failReason': None,
        'state': '16158',
        'buttons': [
            {
                'customId': 'MJ::JOB::upsample::1::b1290620-0d25-4882-a72d-102dc174fc22',
                'emoji': '',
                'label': 'U1',
                'type': 2,
                'style': 2
            },
            {
                'customId': 'MJ::JOB::upsample::2::b1290620-0d25-4882-a72d-102dc174fc22',
                'emoji': '',
                'label': 'U2',
                'type': 2,
                'style': 2
            },
            {
                'customId': 'MJ::JOB::upsample::3::b1290620-0d25-4882-a72d-102dc174fc22',
                'emoji': '',
                'label': 'U3',
                'type': 2,
                'style': 2
            },
            {
                'customId': 'MJ::JOB::upsample::4::b1290620-0d25-4882-a72d-102dc174fc22',
                'emoji': '',
                'label': 'U4',
                'type': 2,
                'style': 2
            },
            {
                'customId': 'MJ::JOB::reroll::0::b1290620-0d25-4882-a72d-102dc174fc22::SOLO',
                'emoji': '🔄',
                'label': '',
                'type': 2,
                'style': 2
            },
            {
                'customId': 'MJ::JOB::variation::1::b1290620-0d25-4882-a72d-102dc174fc22',
                'emoji': '',
                'label': 'V1',
                'type': 2,
                'style': 2
            },
            {
                'customId': 'MJ::JOB::variation::2::b1290620-0d25-4882-a72d-102dc174fc22',
                'emoji': '',
                'label': 'V2',
                'type': 2,
                'style': 2
            },
            {
                'customId': 'MJ::JOB::variation::3::b1290620-0d25-4882-a72d-102dc174fc22',
                'emoji': '',
                'label': 'V3',
                'type': 2,
                'style': 2
            },
            {
                'customId': 'MJ::JOB::variation::4::b1290620-0d25-4882-a72d-102dc174fc22',
                'emoji': '',
                'label': 'V4',
                'type': 2,
                'style': 2
            }
        ]
    }

python复制代码class AssistantNovel(object):

    def __init__(self):
        self.chat = ChatBotHandler()

    def get_response(self,prompt, history):
        return self.chat.signChat(history)

    def clear_chat_history(self):
        st.session_state.messages = [{"role": "assistant", "content": "🍭🍡你好！我是全能创作助手~小汐🥰，可以帮助您完善补充文案细节？🧐"}]

    def page(self):
        # 主聊天对话窗口
        prompt = st.chat_input(placeholder="请输入对话")

        if "messages" not in st.session_state.keys():
            st.session_state.messages = [{"role": "assistant", "content": "🍭🍡你好！我是全能创作助手~小汐🥰，可以帮助您完善补充文案细节？🧐"}]

        for message in st.session_state.messages:
            with st.chat_message(message["role"]):
                st.write(message["content"])
        if prompt:
            st.session_state.messages.append({"role": "user", "content": prompt})
            with st.chat_message("user"):
                st.write(prompt)

        if st.session_state.messages[-1]["role"] != "assistant":
            with st.chat_message("assistant"):
                with st.spinner("Thinking..."):
                    try:
                        response = self.get_response(prompt,st.session_state.messages)
                    except Exception as e:
                        print(e)
                        response = "哦┗|｀O′|┛ 嗷~~，出错了，请稍后再试！😥"
                    placeholder = st.empty()
                    full_response = ''
                    for item in response:
                        full_response += item
                        time.sleep(0.01)
                        placeholder.markdown(full_response)
                    placeholder.markdown(full_response)
            message = {"role": "assistant", "content": full_response}
            st.session_state.messages.append(message)
        st.button('清空历史对话', on_click=self.clear_chat_history)

python复制代码response = self.get_response(prompt,st.session_state.messages)

sql复制代码SHOW DATABASES;

sql复制代码USE coderhub;

sql复制代码SELECT DATABASE();

sql复制代码CREATE DATABASE IF NOT EXISTS mycode;

sql复制代码DROP DATABASE IF EXISTS mycode;

sql复制代码ALTER DATABASE coderhub CHARACTER SET = utf8 COLLATE = utf8_unicode_ci;

sql复制代码SHOW TABLES;

sql复制代码DESC user;

sql复制代码CREATE TABLE IF NOT EXISTS `grades`(
  name VARCHAR(10),
  age INT,
  height DOUBLE
)

sql复制代码DROP TABLE IF EXISTS `user`;

sql复制代码CREATE TABLE IF NOT EXISTS `myuser`(
  id INT PRIMARY KEY AUTO_INCREMENT,
  name VARCHAR(20) UNIQUE NOT NULL,
  level INT DEFAULT 0,
  telPhone VARCHAR(20) UNIQUE NOT NULL
);

sql复制代码ALTER TABLE `myuser` RENAME TO `user`;

sql复制代码ALTER TABLE `user` ADD `publishTime` DATETIME;
ALTER TABLE `user` ADD `updateTime` DATETIME;

sql复制代码ALTER TABLE `user` DROP `updateTime`;

sql复制代码ALTER TABLE `user` CHANGE `publishTime` `publishDate` DATE;

sql复制代码ALTER TABLE `user` MODIFY `id` INT;

sql复制代码CREATE TABLE IF NOT EXISTS `products`(
	`id` INT PRIMARY KEY AUTO_INCREMENT,
	`title` VARCHAR(20),
	`decription` VARCHAR(200),
	`price` DOUBLE,
	`publishTime` DATETIME  
)

sql复制代码INSERT INTO `products`(title,decription,price,publishTime) VALUES ('iphone100','iphone100只要价格998',998,'2021-10-09');
INSERT INTO `products`(title,decription,price,publishTime) VALUES ('huawei','huawei-mate70价格只要1000',1000,'2021-10-10');
INSERT INTO `products`(title,decription,price,publishTime) VALUES('vivo','vivo x60只需要1200',1200,'2021-10-11');

sql复制代码DELETE from 'products';

sql复制代码DELETE FROM `products` WHERE id = 3;

sql复制代码UPDATE `products` SET decription = '假的别买';

sql复制代码UPDATE `products` SET decription = '好手机666' WHERE id=2;

sql复制代码ALTER TABLE `products` ADD `updateTime` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP;